API Reference

Ajax

ajaxAllstar2021VoteVotePost

ajax/allstar2021_vote/vote


/ajax/allstar2021_vote/vote

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax/allstar2021_vote/vote" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxAllstar2021VoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxAllstar2021VoteVotePost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxAllstar2021VoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxAllstar2021VoteVotePost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/allstar2021_vote/vote
[apiInstance ajaxAllstar2021VoteVotePostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxAllstar2021VoteVotePost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxAllstar2021VoteVotePostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/allstar2021_vote/vote
                apiInstance.ajaxAllstar2021VoteVotePost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxAllstar2021VoteVotePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxAllstar2021VoteVotePost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxAllstar2021VoteVotePost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxAllstar2021VoteVotePost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxAllstar2021VoteVotePost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/allstar2021_vote/vote
    api_instance.ajax_allstar2021_vote_vote_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxAllstar2021VoteVotePost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxAllstar2021VoteVotePost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxAllstarVoteSetReadDisplayDialogPost

ajax/allstar_vote/set_read_display_dialog


/ajax/allstar_vote/set_read_display_dialog

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax/allstar_vote/set_read_display_dialog" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxAllstarVoteSetReadDisplayDialogPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxAllstarVoteSetReadDisplayDialogPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxAllstarVoteSetReadDisplayDialogPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxAllstarVoteSetReadDisplayDialogPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/allstar_vote/set_read_display_dialog
[apiInstance ajaxAllstarVoteSetReadDisplayDialogPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxAllstarVoteSetReadDisplayDialogPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxAllstarVoteSetReadDisplayDialogPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/allstar_vote/set_read_display_dialog
                apiInstance.ajaxAllstarVoteSetReadDisplayDialogPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxAllstarVoteSetReadDisplayDialogPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxAllstarVoteSetReadDisplayDialogPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxAllstarVoteSetReadDisplayDialogPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxAllstarVoteSetReadDisplayDialogPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxAllstarVoteSetReadDisplayDialogPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/allstar_vote/set_read_display_dialog
    api_instance.ajax_allstar_vote_set_read_display_dialog_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxAllstarVoteSetReadDisplayDialogPost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxAllstarVoteSetReadDisplayDialogPost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxAllstarVoteVoteGet

ajax/allstar_vote/reset_vote


/ajax/allstar_vote/vote

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/ajax/allstar_vote/vote"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxAllstarVoteVoteGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxAllstarVoteVoteGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxAllstarVoteVoteGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxAllstarVoteVoteGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];

// ajax/allstar_vote/reset_vote
[apiInstance ajaxAllstarVoteVoteGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxAllstarVoteVoteGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxAllstarVoteVoteGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();

            try {
                // ajax/allstar_vote/reset_vote
                apiInstance.ajaxAllstarVoteVoteGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxAllstarVoteVoteGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();

try {
    $api_instance->ajaxAllstarVoteVoteGet();
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxAllstarVoteVoteGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();

eval {
    $api_instance->ajaxAllstarVoteVoteGet();
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxAllstarVoteVoteGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()

try:
    # ajax/allstar_vote/reset_vote
    api_instance.ajax_allstar_vote_vote_get()
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxAllstarVoteVoteGet: %s\n" % e)
extern crate AjaxApi;

pub fn main() {

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxAllstarVoteVoteGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


ajaxAllstarVoteVotePost

ajax/allstar_vote/vote


/ajax/allstar_vote/vote

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax/allstar_vote/vote" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxAllstarVoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxAllstarVoteVotePost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxAllstarVoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxAllstarVoteVotePost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/allstar_vote/vote
[apiInstance ajaxAllstarVoteVotePostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxAllstarVoteVotePost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxAllstarVoteVotePostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/allstar_vote/vote
                apiInstance.ajaxAllstarVoteVotePost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxAllstarVoteVotePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxAllstarVoteVotePost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxAllstarVoteVotePost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxAllstarVoteVotePost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxAllstarVoteVotePost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/allstar_vote/vote
    api_instance.ajax_allstar_vote_vote_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxAllstarVoteVotePost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxAllstarVoteVotePost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxAltairVoteVotePost

ajax/altair_vote/vote


/ajax/altair_vote/vote

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax/altair_vote/vote" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxAltairVoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxAltairVoteVotePost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxAltairVoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxAltairVoteVotePost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/altair_vote/vote
[apiInstance ajaxAltairVoteVotePostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxAltairVoteVotePost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxAltairVoteVotePostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/altair_vote/vote
                apiInstance.ajaxAltairVoteVotePost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxAltairVoteVotePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxAltairVoteVotePost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxAltairVoteVotePost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxAltairVoteVotePost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxAltairVoteVotePost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/altair_vote/vote
    api_instance.ajax_altair_vote_vote_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxAltairVoteVotePost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxAltairVoteVotePost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxAuthPost

ajax/auth


/ajax/auth

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax/auth" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxAuthPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxAuthPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxAuthPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxAuthPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/auth
[apiInstance ajaxAuthPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxAuthPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxAuthPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/auth
                apiInstance.ajaxAuthPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxAuthPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxAuthPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxAuthPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxAuthPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxAuthPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/auth
    api_instance.ajax_auth_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxAuthPost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxAuthPost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxBlockPost

ajax/block


/ajax/block

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax/block" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxBlockPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxBlockPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxBlockPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxBlockPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/block
[apiInstance ajaxBlockPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxBlockPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxBlockPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/block
                apiInstance.ajaxBlockPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxBlockPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxBlockPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxBlockPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxBlockPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxBlockPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/block
    api_instance.ajax_block_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxBlockPost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxBlockPost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxCardSeriesVoteVotePost

ajax/card_series_vote/vote


/ajax/card_series_vote/vote

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax/card_series_vote/vote" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxCardSeriesVoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxCardSeriesVoteVotePost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxCardSeriesVoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxCardSeriesVoteVotePost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/card_series_vote/vote
[apiInstance ajaxCardSeriesVoteVotePostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxCardSeriesVoteVotePost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxCardSeriesVoteVotePostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/card_series_vote/vote
                apiInstance.ajaxCardSeriesVoteVotePost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxCardSeriesVoteVotePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxCardSeriesVoteVotePost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxCardSeriesVoteVotePost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxCardSeriesVoteVotePost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxCardSeriesVoteVotePost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/card_series_vote/vote
    api_instance.ajax_card_series_vote_vote_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxCardSeriesVoteVotePost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxCardSeriesVoteVotePost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxCheckPurchasablePost

ajax/check_purchasable


/ajax/check_purchasable

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax/check_purchasable" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxCheckPurchasablePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxCheckPurchasablePost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxCheckPurchasablePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxCheckPurchasablePost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/check_purchasable
[apiInstance ajaxCheckPurchasablePostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxCheckPurchasablePost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxCheckPurchasablePostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/check_purchasable
                apiInstance.ajaxCheckPurchasablePost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxCheckPurchasablePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxCheckPurchasablePost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxCheckPurchasablePost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxCheckPurchasablePost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxCheckPurchasablePost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/check_purchasable
    api_instance.ajax_check_purchasable_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxCheckPurchasablePost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxCheckPurchasablePost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxDebugTerminalReplaceGet

ajax/debug_terminal/replace


/ajax/debug_terminal/replace

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/ajax/debug_terminal/replace"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxDebugTerminalReplaceGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxDebugTerminalReplaceGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxDebugTerminalReplaceGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxDebugTerminalReplaceGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];

// ajax/debug_terminal/replace
[apiInstance ajaxDebugTerminalReplaceGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxDebugTerminalReplaceGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxDebugTerminalReplaceGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();

            try {
                // ajax/debug_terminal/replace
                apiInstance.ajaxDebugTerminalReplaceGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxDebugTerminalReplaceGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();

try {
    $api_instance->ajaxDebugTerminalReplaceGet();
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxDebugTerminalReplaceGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();

eval {
    $api_instance->ajaxDebugTerminalReplaceGet();
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxDebugTerminalReplaceGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()

try:
    # ajax/debug_terminal/replace
    api_instance.ajax_debug_terminal_replace_get()
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxDebugTerminalReplaceGet: %s\n" % e)
extern crate AjaxApi;

pub fn main() {

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxDebugTerminalReplaceGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


ajaxDreamteamSetDeckPost

ajax/dreamteam/set_deck


/ajax/dreamteam/set_deck

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax/dreamteam/set_deck" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxDreamteamSetDeckPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxDreamteamSetDeckPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxDreamteamSetDeckPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxDreamteamSetDeckPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/dreamteam/set_deck
[apiInstance ajaxDreamteamSetDeckPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxDreamteamSetDeckPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxDreamteamSetDeckPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/dreamteam/set_deck
                apiInstance.ajaxDreamteamSetDeckPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxDreamteamSetDeckPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxDreamteamSetDeckPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxDreamteamSetDeckPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxDreamteamSetDeckPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxDreamteamSetDeckPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/dreamteam/set_deck
    api_instance.ajax_dreamteam_set_deck_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxDreamteamSetDeckPost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxDreamteamSetDeckPost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxDreamteamSetPost

ajax/dreamteam/set


/ajax/dreamteam/set

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax/dreamteam/set" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxDreamteamSetPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxDreamteamSetPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxDreamteamSetPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxDreamteamSetPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/dreamteam/set
[apiInstance ajaxDreamteamSetPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxDreamteamSetPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxDreamteamSetPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/dreamteam/set
                apiInstance.ajaxDreamteamSetPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxDreamteamSetPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxDreamteamSetPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxDreamteamSetPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxDreamteamSetPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxDreamteamSetPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/dreamteam/set
    api_instance.ajax_dreamteam_set_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxDreamteamSetPost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxDreamteamSetPost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxDreamteamVoteVoteGet

ajax/allstar2021_vote/reset_vote


/ajax/dreamteam_vote/vote

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/ajax/dreamteam_vote/vote"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxDreamteamVoteVoteGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxDreamteamVoteVoteGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxDreamteamVoteVoteGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxDreamteamVoteVoteGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];

// ajax/allstar2021_vote/reset_vote
[apiInstance ajaxDreamteamVoteVoteGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxDreamteamVoteVoteGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxDreamteamVoteVoteGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();

            try {
                // ajax/allstar2021_vote/reset_vote
                apiInstance.ajaxDreamteamVoteVoteGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxDreamteamVoteVoteGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();

try {
    $api_instance->ajaxDreamteamVoteVoteGet();
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxDreamteamVoteVoteGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();

eval {
    $api_instance->ajaxDreamteamVoteVoteGet();
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxDreamteamVoteVoteGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()

try:
    # ajax/allstar2021_vote/reset_vote
    api_instance.ajax_dreamteam_vote_vote_get()
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxDreamteamVoteVoteGet: %s\n" % e)
extern crate AjaxApi;

pub fn main() {

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxDreamteamVoteVoteGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


ajaxDreamteamVoteVotePost

ajax/dreamteam_vote/vote


/ajax/dreamteam_vote/vote

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax/dreamteam_vote/vote" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxDreamteamVoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxDreamteamVoteVotePost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxDreamteamVoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxDreamteamVoteVotePost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/dreamteam_vote/vote
[apiInstance ajaxDreamteamVoteVotePostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxDreamteamVoteVotePost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxDreamteamVoteVotePostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/dreamteam_vote/vote
                apiInstance.ajaxDreamteamVoteVotePost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxDreamteamVoteVotePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxDreamteamVoteVotePost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxDreamteamVoteVotePost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxDreamteamVoteVotePost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxDreamteamVoteVotePost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/dreamteam_vote/vote
    api_instance.ajax_dreamteam_vote_vote_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxDreamteamVoteVotePost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxDreamteamVoteVotePost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxForecastClearCardPost

ajax/forecast/clear_card


/ajax/forecast/clear_card

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax/forecast/clear_card" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastClearCardPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastClearCardPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastClearCardPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastClearCardPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/forecast/clear_card
[apiInstance ajaxForecastClearCardPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxForecastClearCardPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxForecastClearCardPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/forecast/clear_card
                apiInstance.ajaxForecastClearCardPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxForecastClearCardPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxForecastClearCardPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxForecastClearCardPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxForecastClearCardPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxForecastClearCardPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/forecast/clear_card
    api_instance.ajax_forecast_clear_card_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxForecastClearCardPost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxForecastClearCardPost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxForecastExchangeRewardPost

ajax/forecast/exchange_reward


/ajax/forecast/exchange_reward

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax/forecast/exchange_reward" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastExchangeRewardPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastExchangeRewardPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastExchangeRewardPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastExchangeRewardPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/forecast/exchange_reward
[apiInstance ajaxForecastExchangeRewardPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxForecastExchangeRewardPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxForecastExchangeRewardPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/forecast/exchange_reward
                apiInstance.ajaxForecastExchangeRewardPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxForecastExchangeRewardPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxForecastExchangeRewardPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxForecastExchangeRewardPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxForecastExchangeRewardPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxForecastExchangeRewardPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/forecast/exchange_reward
    api_instance.ajax_forecast_exchange_reward_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxForecastExchangeRewardPost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxForecastExchangeRewardPost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxForecastExecAutoCardSetGet

ajax/forecast/exec_auto_card_set


/ajax/forecast/exec_auto_card_set

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/ajax/forecast/exec_auto_card_set"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxForecastExecAutoCardSetGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastExecAutoCardSetGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxForecastExecAutoCardSetGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastExecAutoCardSetGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];

// ajax/forecast/exec_auto_card_set
[apiInstance ajaxForecastExecAutoCardSetGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxForecastExecAutoCardSetGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxForecastExecAutoCardSetGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();

            try {
                // ajax/forecast/exec_auto_card_set
                apiInstance.ajaxForecastExecAutoCardSetGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxForecastExecAutoCardSetGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();

try {
    $api_instance->ajaxForecastExecAutoCardSetGet();
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxForecastExecAutoCardSetGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();

eval {
    $api_instance->ajaxForecastExecAutoCardSetGet();
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxForecastExecAutoCardSetGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()

try:
    # ajax/forecast/exec_auto_card_set
    api_instance.ajax_forecast_exec_auto_card_set_get()
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxForecastExecAutoCardSetGet: %s\n" % e)
extern crate AjaxApi;

pub fn main() {

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxForecastExecAutoCardSetGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


ajaxForecastGetBadgeSettingGet

ajax/forecast/get_badge_setting


/ajax/forecast/get_badge_setting

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/ajax/forecast/get_badge_setting"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxForecastGetBadgeSettingGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastGetBadgeSettingGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxForecastGetBadgeSettingGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastGetBadgeSettingGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];

// ajax/forecast/get_badge_setting
[apiInstance ajaxForecastGetBadgeSettingGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxForecastGetBadgeSettingGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxForecastGetBadgeSettingGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();

            try {
                // ajax/forecast/get_badge_setting
                apiInstance.ajaxForecastGetBadgeSettingGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxForecastGetBadgeSettingGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();

try {
    $api_instance->ajaxForecastGetBadgeSettingGet();
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxForecastGetBadgeSettingGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();

eval {
    $api_instance->ajaxForecastGetBadgeSettingGet();
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxForecastGetBadgeSettingGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()

try:
    # ajax/forecast/get_badge_setting
    api_instance.ajax_forecast_get_badge_setting_get()
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxForecastGetBadgeSettingGet: %s\n" % e)
extern crate AjaxApi;

pub fn main() {

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxForecastGetBadgeSettingGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


ajaxForecastGetGameScheduleGet

ajax/forecast/get_game_schedule


/ajax/forecast/get_game_schedule

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/ajax/forecast/get_game_schedule"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxForecastGetGameScheduleGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastGetGameScheduleGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxForecastGetGameScheduleGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastGetGameScheduleGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];

// ajax/forecast/get_game_schedule
[apiInstance ajaxForecastGetGameScheduleGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxForecastGetGameScheduleGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxForecastGetGameScheduleGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();

            try {
                // ajax/forecast/get_game_schedule
                apiInstance.ajaxForecastGetGameScheduleGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxForecastGetGameScheduleGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();

try {
    $api_instance->ajaxForecastGetGameScheduleGet();
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxForecastGetGameScheduleGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();

eval {
    $api_instance->ajaxForecastGetGameScheduleGet();
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxForecastGetGameScheduleGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()

try:
    # ajax/forecast/get_game_schedule
    api_instance.ajax_forecast_get_game_schedule_get()
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxForecastGetGameScheduleGet: %s\n" % e)
extern crate AjaxApi;

pub fn main() {

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxForecastGetGameScheduleGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


ajaxForecastGetSeasonRanksPost

ajax/forecast/get_season_ranks


/ajax/forecast/get_season_ranks

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax/forecast/get_season_ranks" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastGetSeasonRanksPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastGetSeasonRanksPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastGetSeasonRanksPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastGetSeasonRanksPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/forecast/get_season_ranks
[apiInstance ajaxForecastGetSeasonRanksPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxForecastGetSeasonRanksPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxForecastGetSeasonRanksPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/forecast/get_season_ranks
                apiInstance.ajaxForecastGetSeasonRanksPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxForecastGetSeasonRanksPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxForecastGetSeasonRanksPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxForecastGetSeasonRanksPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxForecastGetSeasonRanksPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxForecastGetSeasonRanksPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/forecast/get_season_ranks
    api_instance.ajax_forecast_get_season_ranks_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxForecastGetSeasonRanksPost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxForecastGetSeasonRanksPost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxForecastGetSectionRanksPost

ajax/forecast/get_section_ranks


/ajax/forecast/get_section_ranks

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax/forecast/get_section_ranks" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastGetSectionRanksPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastGetSectionRanksPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastGetSectionRanksPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastGetSectionRanksPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/forecast/get_section_ranks
[apiInstance ajaxForecastGetSectionRanksPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxForecastGetSectionRanksPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxForecastGetSectionRanksPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/forecast/get_section_ranks
                apiInstance.ajaxForecastGetSectionRanksPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxForecastGetSectionRanksPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxForecastGetSectionRanksPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxForecastGetSectionRanksPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxForecastGetSectionRanksPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxForecastGetSectionRanksPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/forecast/get_section_ranks
    api_instance.ajax_forecast_get_section_ranks_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxForecastGetSectionRanksPost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxForecastGetSectionRanksPost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxForecastIsSlotEditablePost

ajax/forecast/is_slot_editable


/ajax/forecast/is_slot_editable

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax/forecast/is_slot_editable" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastIsSlotEditablePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastIsSlotEditablePost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastIsSlotEditablePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastIsSlotEditablePost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/forecast/is_slot_editable
[apiInstance ajaxForecastIsSlotEditablePostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxForecastIsSlotEditablePost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxForecastIsSlotEditablePostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/forecast/is_slot_editable
                apiInstance.ajaxForecastIsSlotEditablePost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxForecastIsSlotEditablePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxForecastIsSlotEditablePost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxForecastIsSlotEditablePost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxForecastIsSlotEditablePost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxForecastIsSlotEditablePost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/forecast/is_slot_editable
    api_instance.ajax_forecast_is_slot_editable_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxForecastIsSlotEditablePost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxForecastIsSlotEditablePost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxForecastSaveCardsPost

ajax/forecast/save_cards


/ajax/forecast/save_cards

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax/forecast/save_cards" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastSaveCardsPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastSaveCardsPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastSaveCardsPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastSaveCardsPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/forecast/save_cards
[apiInstance ajaxForecastSaveCardsPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxForecastSaveCardsPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxForecastSaveCardsPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/forecast/save_cards
                apiInstance.ajaxForecastSaveCardsPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxForecastSaveCardsPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxForecastSaveCardsPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxForecastSaveCardsPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxForecastSaveCardsPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxForecastSaveCardsPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/forecast/save_cards
    api_instance.ajax_forecast_save_cards_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxForecastSaveCardsPost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxForecastSaveCardsPost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxForecastSelectCardPost

ajax/forecast/select_card


/ajax/forecast/select_card

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax/forecast/select_card" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastSelectCardPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastSelectCardPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastSelectCardPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastSelectCardPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/forecast/select_card
[apiInstance ajaxForecastSelectCardPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxForecastSelectCardPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxForecastSelectCardPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/forecast/select_card
                apiInstance.ajaxForecastSelectCardPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxForecastSelectCardPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxForecastSelectCardPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxForecastSelectCardPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxForecastSelectCardPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxForecastSelectCardPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/forecast/select_card
    api_instance.ajax_forecast_select_card_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxForecastSelectCardPost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxForecastSelectCardPost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxForecastSetBadgePost

ajax/forecast/set_badge


/ajax/forecast/set_badge

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax/forecast/set_badge" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastSetBadgePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastSetBadgePost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxForecastSetBadgePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxForecastSetBadgePost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/forecast/set_badge
[apiInstance ajaxForecastSetBadgePostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxForecastSetBadgePost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxForecastSetBadgePostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/forecast/set_badge
                apiInstance.ajaxForecastSetBadgePost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxForecastSetBadgePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxForecastSetBadgePost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxForecastSetBadgePost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxForecastSetBadgePost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxForecastSetBadgePost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/forecast/set_badge
    api_instance.ajax_forecast_set_badge_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxForecastSetBadgePost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxForecastSetBadgePost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxMascotVoteVotePost

ajax/mascot_vote/vote


/ajax/mascot_vote/vote

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax/mascot_vote/vote" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxMascotVoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxMascotVoteVotePost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxMascotVoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxMascotVoteVotePost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/mascot_vote/vote
[apiInstance ajaxMascotVoteVotePostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxMascotVoteVotePost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxMascotVoteVotePostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/mascot_vote/vote
                apiInstance.ajaxMascotVoteVotePost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxMascotVoteVotePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxMascotVoteVotePost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxMascotVoteVotePost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxMascotVoteVotePost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxMascotVoteVotePost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/mascot_vote/vote
    api_instance.ajax_mascot_vote_vote_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxMascotVoteVotePost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxMascotVoteVotePost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxMinimailBlockPost

ajax/minimail/block


/ajax/minimail/block

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax/minimail/block" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxMinimailBlockPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxMinimailBlockPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxMinimailBlockPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxMinimailBlockPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/minimail/block
[apiInstance ajaxMinimailBlockPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxMinimailBlockPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxMinimailBlockPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/minimail/block
                apiInstance.ajaxMinimailBlockPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxMinimailBlockPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxMinimailBlockPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxMinimailBlockPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxMinimailBlockPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxMinimailBlockPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/minimail/block
    api_instance.ajax_minimail_block_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxMinimailBlockPost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxMinimailBlockPost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxMinimailListPost

ajax/minimail/list


/ajax/minimail/list

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax/minimail/list" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxMinimailListPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxMinimailListPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxMinimailListPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxMinimailListPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/minimail/list
[apiInstance ajaxMinimailListPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxMinimailListPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxMinimailListPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/minimail/list
                apiInstance.ajaxMinimailListPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxMinimailListPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxMinimailListPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxMinimailListPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxMinimailListPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxMinimailListPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/minimail/list
    api_instance.ajax_minimail_list_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxMinimailListPost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxMinimailListPost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxMinimailPullAnyPost

ajax/minimail/pull/(:any)


/ajax/minimail/pull/(:any)

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax/minimail/pull/(:any)" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxMinimailPullAnyPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxMinimailPullAnyPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxMinimailPullAnyPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxMinimailPullAnyPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/minimail/pull/(:any)
[apiInstance ajaxMinimailPullAnyPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxMinimailPullAnyPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxMinimailPullAnyPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/minimail/pull/(:any)
                apiInstance.ajaxMinimailPullAnyPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxMinimailPullAnyPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxMinimailPullAnyPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxMinimailPullAnyPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxMinimailPullAnyPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxMinimailPullAnyPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/minimail/pull/(:any)
    api_instance.ajax_minimail_pull_any_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxMinimailPullAnyPost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxMinimailPullAnyPost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxNoticePost

ajax/notice


/ajax/notice

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax/notice" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxNoticePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxNoticePost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxNoticePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxNoticePost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/notice
[apiInstance ajaxNoticePostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxNoticePost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxNoticePostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/notice
                apiInstance.ajaxNoticePost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxNoticePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxNoticePost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxNoticePost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxNoticePost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxNoticePost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/notice
    api_instance.ajax_notice_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxNoticePost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxNoticePost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxNoticeSetMyClubPost

ajax_notice_set_my_club


/ajax_notice_set_my_club

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax_notice_set_my_club" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxNoticeSetMyClubPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxNoticeSetMyClubPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxNoticeSetMyClubPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxNoticeSetMyClubPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax_notice_set_my_club
[apiInstance ajaxNoticeSetMyClubPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxNoticeSetMyClubPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxNoticeSetMyClubPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax_notice_set_my_club
                apiInstance.ajaxNoticeSetMyClubPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxNoticeSetMyClubPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxNoticeSetMyClubPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxNoticeSetMyClubPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxNoticeSetMyClubPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxNoticeSetMyClubPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax_notice_set_my_club
    api_instance.ajax_notice_set_my_club_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxNoticeSetMyClubPost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxNoticeSetMyClubPost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxPostUploadPost

ajax/post/upload


/ajax/post/upload

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax/post/upload" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxPostUploadPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPostUploadPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxPostUploadPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPostUploadPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/post/upload
[apiInstance ajaxPostUploadPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxPostUploadPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxPostUploadPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/post/upload
                apiInstance.ajaxPostUploadPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxPostUploadPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxPostUploadPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxPostUploadPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxPostUploadPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxPostUploadPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/post/upload
    api_instance.ajax_post_upload_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxPostUploadPost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxPostUploadPost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxPullUserNoticeGet

ajax_pull_user_notice


/ajax_pull_user_notice

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/ajax_pull_user_notice"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxPullUserNoticeGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPullUserNoticeGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxPullUserNoticeGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPullUserNoticeGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];

// ajax_pull_user_notice
[apiInstance ajaxPullUserNoticeGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxPullUserNoticeGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxPullUserNoticeGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();

            try {
                // ajax_pull_user_notice
                apiInstance.ajaxPullUserNoticeGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxPullUserNoticeGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();

try {
    $api_instance->ajaxPullUserNoticeGet();
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxPullUserNoticeGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();

eval {
    $api_instance->ajaxPullUserNoticeGet();
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxPullUserNoticeGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()

try:
    # ajax_pull_user_notice
    api_instance.ajax_pull_user_notice_get()
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxPullUserNoticeGet: %s\n" % e)
extern crate AjaxApi;

pub fn main() {

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxPullUserNoticeGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


ajaxPurchaseItemsGet

ajax/purchase_items


/ajax/purchase_items

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/ajax/purchase_items"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxPurchaseItemsGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPurchaseItemsGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();

        try {
            apiInstance.ajaxPurchaseItemsGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPurchaseItemsGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];

// ajax/purchase_items
[apiInstance ajaxPurchaseItemsGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxPurchaseItemsGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxPurchaseItemsGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();

            try {
                // ajax/purchase_items
                apiInstance.ajaxPurchaseItemsGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxPurchaseItemsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();

try {
    $api_instance->ajaxPurchaseItemsGet();
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxPurchaseItemsGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();

eval {
    $api_instance->ajaxPurchaseItemsGet();
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxPurchaseItemsGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()

try:
    # ajax/purchase_items
    api_instance.ajax_purchase_items_get()
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxPurchaseItemsGet: %s\n" % e)
extern crate AjaxApi;

pub fn main() {

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxPurchaseItemsGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


ajaxPushCardNewReadPost

ajax_push_card_new_read


/ajax_push_card_new_read

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax_push_card_new_read" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxPushCardNewReadPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPushCardNewReadPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxPushCardNewReadPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPushCardNewReadPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax_push_card_new_read
[apiInstance ajaxPushCardNewReadPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxPushCardNewReadPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxPushCardNewReadPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax_push_card_new_read
                apiInstance.ajaxPushCardNewReadPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxPushCardNewReadPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxPushCardNewReadPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxPushCardNewReadPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxPushCardNewReadPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxPushCardNewReadPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax_push_card_new_read
    api_instance.ajax_push_card_new_read_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxPushCardNewReadPost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxPushCardNewReadPost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxPushOshiraseOkPost

ajax_push_oshirase_ok


/ajax_push_oshirase_ok

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax_push_oshirase_ok" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxPushOshiraseOkPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPushOshiraseOkPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxPushOshiraseOkPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPushOshiraseOkPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax_push_oshirase_ok
[apiInstance ajaxPushOshiraseOkPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxPushOshiraseOkPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxPushOshiraseOkPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax_push_oshirase_ok
                apiInstance.ajaxPushOshiraseOkPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxPushOshiraseOkPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxPushOshiraseOkPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxPushOshiraseOkPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxPushOshiraseOkPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxPushOshiraseOkPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax_push_oshirase_ok
    api_instance.ajax_push_oshirase_ok_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxPushOshiraseOkPost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxPushOshiraseOkPost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxPushOshiraseReadPost

ajax_push_oshirase_read


/ajax_push_oshirase_read

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax_push_oshirase_read" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxPushOshiraseReadPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPushOshiraseReadPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxPushOshiraseReadPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPushOshiraseReadPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax_push_oshirase_read
[apiInstance ajaxPushOshiraseReadPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxPushOshiraseReadPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxPushOshiraseReadPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax_push_oshirase_read
                apiInstance.ajaxPushOshiraseReadPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxPushOshiraseReadPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxPushOshiraseReadPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxPushOshiraseReadPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxPushOshiraseReadPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxPushOshiraseReadPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax_push_oshirase_read
    api_instance.ajax_push_oshirase_read_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxPushOshiraseReadPost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxPushOshiraseReadPost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxPushUserNoticeReadPost

ajax_push_user_notice_read


/ajax_push_user_notice_read

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax_push_user_notice_read" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxPushUserNoticeReadPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPushUserNoticeReadPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxPushUserNoticeReadPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPushUserNoticeReadPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax_push_user_notice_read
[apiInstance ajaxPushUserNoticeReadPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxPushUserNoticeReadPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxPushUserNoticeReadPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax_push_user_notice_read
                apiInstance.ajaxPushUserNoticeReadPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxPushUserNoticeReadPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxPushUserNoticeReadPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxPushUserNoticeReadPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxPushUserNoticeReadPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxPushUserNoticeReadPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax_push_user_notice_read
    api_instance.ajax_push_user_notice_read_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxPushUserNoticeReadPost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxPushUserNoticeReadPost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxPushUserOshirasesReadPost

ajax_push_user_oshirases_read


/ajax_push_user_oshirases_read

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax_push_user_oshirases_read" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxPushUserOshirasesReadPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPushUserOshirasesReadPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxPushUserOshirasesReadPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxPushUserOshirasesReadPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax_push_user_oshirases_read
[apiInstance ajaxPushUserOshirasesReadPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxPushUserOshirasesReadPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxPushUserOshirasesReadPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax_push_user_oshirases_read
                apiInstance.ajaxPushUserOshirasesReadPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxPushUserOshirasesReadPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxPushUserOshirasesReadPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxPushUserOshirasesReadPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxPushUserOshirasesReadPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxPushUserOshirasesReadPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax_push_user_oshirases_read
    api_instance.ajax_push_user_oshirases_read_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxPushUserOshirasesReadPost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxPushUserOshirasesReadPost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxSaveHavingFilterPost

ajax_save_having_filter


/ajax_save_having_filter

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax_save_having_filter" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxSaveHavingFilterPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxSaveHavingFilterPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxSaveHavingFilterPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxSaveHavingFilterPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax_save_having_filter
[apiInstance ajaxSaveHavingFilterPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxSaveHavingFilterPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxSaveHavingFilterPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax_save_having_filter
                apiInstance.ajaxSaveHavingFilterPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxSaveHavingFilterPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxSaveHavingFilterPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxSaveHavingFilterPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxSaveHavingFilterPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxSaveHavingFilterPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax_save_having_filter
    api_instance.ajax_save_having_filter_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxSaveHavingFilterPost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxSaveHavingFilterPost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxSaveHolderSortPost

ajax_save_holder_sort


/ajax_save_holder_sort

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax_save_holder_sort" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxSaveHolderSortPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxSaveHolderSortPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxSaveHolderSortPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxSaveHolderSortPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax_save_holder_sort
[apiInstance ajaxSaveHolderSortPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxSaveHolderSortPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxSaveHolderSortPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax_save_holder_sort
                apiInstance.ajaxSaveHolderSortPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxSaveHolderSortPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxSaveHolderSortPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxSaveHolderSortPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxSaveHolderSortPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxSaveHolderSortPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax_save_holder_sort
    api_instance.ajax_save_holder_sort_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxSaveHolderSortPost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxSaveHolderSortPost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxSearchUidPost

ajax/search_uid


/ajax/search_uid

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax/search_uid" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxSearchUidPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxSearchUidPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxSearchUidPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxSearchUidPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/search_uid
[apiInstance ajaxSearchUidPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxSearchUidPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxSearchUidPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/search_uid
                apiInstance.ajaxSearchUidPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxSearchUidPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxSearchUidPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxSearchUidPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxSearchUidPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxSearchUidPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/search_uid
    api_instance.ajax_search_uid_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxSearchUidPost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxSearchUidPost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxValentine2021VoteVotePost

ajax/valentine2021_vote/vote


/ajax/valentine2021_vote/vote

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax/valentine2021_vote/vote" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxValentine2021VoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxValentine2021VoteVotePost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxValentine2021VoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxValentine2021VoteVotePost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/valentine2021_vote/vote
[apiInstance ajaxValentine2021VoteVotePostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxValentine2021VoteVotePost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxValentine2021VoteVotePostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/valentine2021_vote/vote
                apiInstance.ajaxValentine2021VoteVotePost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxValentine2021VoteVotePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxValentine2021VoteVotePost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxValentine2021VoteVotePost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxValentine2021VoteVotePost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxValentine2021VoteVotePost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/valentine2021_vote/vote
    api_instance.ajax_valentine2021_vote_vote_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxValentine2021VoteVotePost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxValentine2021VoteVotePost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


ajaxValentineVoteVotePost

ajax/valentine_vote/vote


/ajax/valentine_vote/vote

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/ajax/valentine_vote/vote" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxValentineVoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxValentineVoteVotePost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.ajaxValentineVoteVotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#ajaxValentineVoteVotePost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/valentine_vote/vote
[apiInstance ajaxValentineVoteVotePostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ajaxValentineVoteVotePost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class ajaxValentineVoteVotePostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/valentine_vote/vote
                apiInstance.ajaxValentineVoteVotePost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.ajaxValentineVoteVotePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->ajaxValentineVoteVotePost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->ajaxValentineVoteVotePost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->ajaxValentineVoteVotePost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->ajaxValentineVoteVotePost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/valentine_vote/vote
    api_instance.ajax_valentine_vote_vote_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->ajaxValentineVoteVotePost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.ajaxValentineVoteVotePost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


userAjaxActivitiesPullPost

ajax/activities/pull


/user/ajax_activities_pull

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/user/ajax_activities_pull" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.userAjaxActivitiesPullPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#userAjaxActivitiesPullPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.userAjaxActivitiesPullPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#userAjaxActivitiesPullPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax/activities/pull
[apiInstance userAjaxActivitiesPullPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.userAjaxActivitiesPullPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class userAjaxActivitiesPullPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax/activities/pull
                apiInstance.userAjaxActivitiesPullPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.userAjaxActivitiesPullPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->userAjaxActivitiesPullPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->userAjaxActivitiesPullPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->userAjaxActivitiesPullPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->userAjaxActivitiesPullPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax/activities/pull
    api_instance.user_ajax_activities_pull_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->userAjaxActivitiesPullPost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.userAjaxActivitiesPullPost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


userAjaxPullPointhistoryPost

ajax_pull_pointhistory


/user/ajax_pull_pointhistory

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/user/ajax_pull_pointhistory" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AjaxApi;

import java.io.File;
import java.util.*;

public class AjaxApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.userAjaxPullPointhistoryPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#userAjaxPullPointhistoryPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AjaxApi;

public class AjaxApiExample {
    public static void main(String[] args) {
        AjaxApi apiInstance = new AjaxApi();
        Object body = Object; // Object | 

        try {
            apiInstance.userAjaxPullPointhistoryPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AjaxApi#userAjaxPullPointhistoryPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AjaxApi *apiInstance = [[AjaxApi alloc] init];
Object *body = Object; //  (optional)

// ajax_pull_pointhistory
[apiInstance userAjaxPullPointhistoryPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AjaxApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.userAjaxPullPointhistoryPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class userAjaxPullPointhistoryPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AjaxApi();
            var body = Object;  // Object |  (optional) 

            try {
                // ajax_pull_pointhistory
                apiInstance.userAjaxPullPointhistoryPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling AjaxApi.userAjaxPullPointhistoryPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AjaxApi();
$body = Object; // Object | 

try {
    $api_instance->userAjaxPullPointhistoryPost($body);
} catch (Exception $e) {
    echo 'Exception when calling AjaxApi->userAjaxPullPointhistoryPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AjaxApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AjaxApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->userAjaxPullPointhistoryPost(body => $body);
};
if ($@) {
    warn "Exception when calling AjaxApi->userAjaxPullPointhistoryPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AjaxApi()
body = Object # Object |  (optional)

try:
    # ajax_pull_pointhistory
    api_instance.user_ajax_pull_pointhistory_post(body=body)
except ApiException as e:
    print("Exception when calling AjaxApi->userAjaxPullPointhistoryPost: %s\n" % e)
extern crate AjaxApi;

pub fn main() {
    let body = Object; // Object

    let mut context = AjaxApi::Context::default();
    let result = client.userAjaxPullPointhistoryPost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


Allstar2021Vote

allstar2021VoteGet

allstar2021_vote


/allstar2021_vote

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/allstar2021_vote?target_year=yyyy"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.Allstar2021VoteApi;

import java.io.File;
import java.util.*;

public class Allstar2021VoteApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        Allstar2021VoteApi apiInstance = new Allstar2021VoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.allstar2021VoteGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling Allstar2021VoteApi#allstar2021VoteGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.Allstar2021VoteApi;

public class Allstar2021VoteApiExample {
    public static void main(String[] args) {
        Allstar2021VoteApi apiInstance = new Allstar2021VoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.allstar2021VoteGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling Allstar2021VoteApi#allstar2021VoteGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
Allstar2021VoteApi *apiInstance = [[Allstar2021VoteApi alloc] init];
String *userAgent = userAgent_example; //  (optional) (default to null)
String *targetYear = yyyy; //  (optional) (default to null)

// allstar2021_vote
[apiInstance allstar2021VoteGetWith:userAgent
    targetYear:targetYear
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.Allstar2021VoteApi()
var opts = {
  'userAgent': userAgent_example, // {String} 
  'targetYear': yyyy // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.allstar2021VoteGet(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class allstar2021VoteGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new Allstar2021VoteApi();
            var userAgent = userAgent_example;  // String |  (optional)  (default to null)
            var targetYear = yyyy;  // String |  (optional)  (default to null)

            try {
                // allstar2021_vote
                apiInstance.allstar2021VoteGet(userAgent, targetYear);
            } catch (Exception e) {
                Debug.Print("Exception when calling Allstar2021VoteApi.allstar2021VoteGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Allstar2021VoteApi();
$userAgent = userAgent_example; // String | 
$targetYear = yyyy; // String | 

try {
    $api_instance->allstar2021VoteGet($userAgent, $targetYear);
} catch (Exception $e) {
    echo 'Exception when calling Allstar2021VoteApi->allstar2021VoteGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Allstar2021VoteApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::Allstar2021VoteApi->new();
my $userAgent = userAgent_example; # String | 
my $targetYear = yyyy; # String | 

eval {
    $api_instance->allstar2021VoteGet(userAgent => $userAgent, targetYear => $targetYear);
};
if ($@) {
    warn "Exception when calling Allstar2021VoteApi->allstar2021VoteGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.Allstar2021VoteApi()
userAgent = userAgent_example # String |  (optional) (default to null)
targetYear = yyyy # String |  (optional) (default to null)

try:
    # allstar2021_vote
    api_instance.allstar2021_vote_get(userAgent=userAgent, targetYear=targetYear)
except ApiException as e:
    print("Exception when calling Allstar2021VoteApi->allstar2021VoteGet: %s\n" % e)
extern crate Allstar2021VoteApi;

pub fn main() {
    let userAgent = userAgent_example; // String
    let targetYear = yyyy; // String

    let mut context = Allstar2021VoteApi::Context::default();
    let result = client.allstar2021VoteGet(userAgent, targetYear, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Header parameters
Name Description
User-Agent
String
Query parameters
Name Description
target_year
String

Responses


allstar2021VoteIndexApiGet

allstar2021_vote/index_api


/allstar2021_vote/index_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/allstar2021_vote/index_api?target_year=yyyy"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.Allstar2021VoteApi;

import java.io.File;
import java.util.*;

public class Allstar2021VoteApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        Allstar2021VoteApi apiInstance = new Allstar2021VoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.allstar2021VoteIndexApiGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling Allstar2021VoteApi#allstar2021VoteIndexApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.Allstar2021VoteApi;

public class Allstar2021VoteApiExample {
    public static void main(String[] args) {
        Allstar2021VoteApi apiInstance = new Allstar2021VoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.allstar2021VoteIndexApiGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling Allstar2021VoteApi#allstar2021VoteIndexApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
Allstar2021VoteApi *apiInstance = [[Allstar2021VoteApi alloc] init];
String *userAgent = userAgent_example; //  (optional) (default to null)
String *targetYear = yyyy; //  (optional) (default to null)

// allstar2021_vote/index_api
[apiInstance allstar2021VoteIndexApiGetWith:userAgent
    targetYear:targetYear
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.Allstar2021VoteApi()
var opts = {
  'userAgent': userAgent_example, // {String} 
  'targetYear': yyyy // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.allstar2021VoteIndexApiGet(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class allstar2021VoteIndexApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new Allstar2021VoteApi();
            var userAgent = userAgent_example;  // String |  (optional)  (default to null)
            var targetYear = yyyy;  // String |  (optional)  (default to null)

            try {
                // allstar2021_vote/index_api
                apiInstance.allstar2021VoteIndexApiGet(userAgent, targetYear);
            } catch (Exception e) {
                Debug.Print("Exception when calling Allstar2021VoteApi.allstar2021VoteIndexApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Allstar2021VoteApi();
$userAgent = userAgent_example; // String | 
$targetYear = yyyy; // String | 

try {
    $api_instance->allstar2021VoteIndexApiGet($userAgent, $targetYear);
} catch (Exception $e) {
    echo 'Exception when calling Allstar2021VoteApi->allstar2021VoteIndexApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Allstar2021VoteApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::Allstar2021VoteApi->new();
my $userAgent = userAgent_example; # String | 
my $targetYear = yyyy; # String | 

eval {
    $api_instance->allstar2021VoteIndexApiGet(userAgent => $userAgent, targetYear => $targetYear);
};
if ($@) {
    warn "Exception when calling Allstar2021VoteApi->allstar2021VoteIndexApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.Allstar2021VoteApi()
userAgent = userAgent_example # String |  (optional) (default to null)
targetYear = yyyy # String |  (optional) (default to null)

try:
    # allstar2021_vote/index_api
    api_instance.allstar2021_vote_index_api_get(userAgent=userAgent, targetYear=targetYear)
except ApiException as e:
    print("Exception when calling Allstar2021VoteApi->allstar2021VoteIndexApiGet: %s\n" % e)
extern crate Allstar2021VoteApi;

pub fn main() {
    let userAgent = userAgent_example; // String
    let targetYear = yyyy; // String

    let mut context = Allstar2021VoteApi::Context::default();
    let result = client.allstar2021VoteIndexApiGet(userAgent, targetYear, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Header parameters
Name Description
User-Agent
String
Query parameters
Name Description
target_year
String

Responses


AllstarVote

allstarVoteGet

allstar_vote


/allstar_vote

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/allstar_vote?target_year=yyyy"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AllstarVoteApi;

import java.io.File;
import java.util.*;

public class AllstarVoteApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AllstarVoteApi apiInstance = new AllstarVoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.allstarVoteGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling AllstarVoteApi#allstarVoteGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AllstarVoteApi;

public class AllstarVoteApiExample {
    public static void main(String[] args) {
        AllstarVoteApi apiInstance = new AllstarVoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.allstarVoteGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling AllstarVoteApi#allstarVoteGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AllstarVoteApi *apiInstance = [[AllstarVoteApi alloc] init];
String *userAgent = userAgent_example; //  (optional) (default to null)
String *targetYear = yyyy; //  (optional) (default to null)

// allstar_vote
[apiInstance allstarVoteGetWith:userAgent
    targetYear:targetYear
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AllstarVoteApi()
var opts = {
  'userAgent': userAgent_example, // {String} 
  'targetYear': yyyy // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.allstarVoteGet(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class allstarVoteGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AllstarVoteApi();
            var userAgent = userAgent_example;  // String |  (optional)  (default to null)
            var targetYear = yyyy;  // String |  (optional)  (default to null)

            try {
                // allstar_vote
                apiInstance.allstarVoteGet(userAgent, targetYear);
            } catch (Exception e) {
                Debug.Print("Exception when calling AllstarVoteApi.allstarVoteGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AllstarVoteApi();
$userAgent = userAgent_example; // String | 
$targetYear = yyyy; // String | 

try {
    $api_instance->allstarVoteGet($userAgent, $targetYear);
} catch (Exception $e) {
    echo 'Exception when calling AllstarVoteApi->allstarVoteGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AllstarVoteApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AllstarVoteApi->new();
my $userAgent = userAgent_example; # String | 
my $targetYear = yyyy; # String | 

eval {
    $api_instance->allstarVoteGet(userAgent => $userAgent, targetYear => $targetYear);
};
if ($@) {
    warn "Exception when calling AllstarVoteApi->allstarVoteGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AllstarVoteApi()
userAgent = userAgent_example # String |  (optional) (default to null)
targetYear = yyyy # String |  (optional) (default to null)

try:
    # allstar_vote
    api_instance.allstar_vote_get(userAgent=userAgent, targetYear=targetYear)
except ApiException as e:
    print("Exception when calling AllstarVoteApi->allstarVoteGet: %s\n" % e)
extern crate AllstarVoteApi;

pub fn main() {
    let userAgent = userAgent_example; // String
    let targetYear = yyyy; // String

    let mut context = AllstarVoteApi::Context::default();
    let result = client.allstarVoteGet(userAgent, targetYear, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Header parameters
Name Description
User-Agent
String
Query parameters
Name Description
target_year
String

Responses


allstarVoteIndexApiGet

allstar_vote/index_api


/allstar_vote/index_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/allstar_vote/index_api?target_year=yyyy"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AllstarVoteApi;

import java.io.File;
import java.util.*;

public class AllstarVoteApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AllstarVoteApi apiInstance = new AllstarVoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.allstarVoteIndexApiGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling AllstarVoteApi#allstarVoteIndexApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AllstarVoteApi;

public class AllstarVoteApiExample {
    public static void main(String[] args) {
        AllstarVoteApi apiInstance = new AllstarVoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.allstarVoteIndexApiGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling AllstarVoteApi#allstarVoteIndexApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AllstarVoteApi *apiInstance = [[AllstarVoteApi alloc] init];
String *userAgent = userAgent_example; //  (optional) (default to null)
String *targetYear = yyyy; //  (optional) (default to null)

// allstar_vote/index_api
[apiInstance allstarVoteIndexApiGetWith:userAgent
    targetYear:targetYear
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AllstarVoteApi()
var opts = {
  'userAgent': userAgent_example, // {String} 
  'targetYear': yyyy // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.allstarVoteIndexApiGet(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class allstarVoteIndexApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AllstarVoteApi();
            var userAgent = userAgent_example;  // String |  (optional)  (default to null)
            var targetYear = yyyy;  // String |  (optional)  (default to null)

            try {
                // allstar_vote/index_api
                apiInstance.allstarVoteIndexApiGet(userAgent, targetYear);
            } catch (Exception e) {
                Debug.Print("Exception when calling AllstarVoteApi.allstarVoteIndexApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AllstarVoteApi();
$userAgent = userAgent_example; // String | 
$targetYear = yyyy; // String | 

try {
    $api_instance->allstarVoteIndexApiGet($userAgent, $targetYear);
} catch (Exception $e) {
    echo 'Exception when calling AllstarVoteApi->allstarVoteIndexApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AllstarVoteApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AllstarVoteApi->new();
my $userAgent = userAgent_example; # String | 
my $targetYear = yyyy; # String | 

eval {
    $api_instance->allstarVoteIndexApiGet(userAgent => $userAgent, targetYear => $targetYear);
};
if ($@) {
    warn "Exception when calling AllstarVoteApi->allstarVoteIndexApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AllstarVoteApi()
userAgent = userAgent_example # String |  (optional) (default to null)
targetYear = yyyy # String |  (optional) (default to null)

try:
    # allstar_vote/index_api
    api_instance.allstar_vote_index_api_get(userAgent=userAgent, targetYear=targetYear)
except ApiException as e:
    print("Exception when calling AllstarVoteApi->allstarVoteIndexApiGet: %s\n" % e)
extern crate AllstarVoteApi;

pub fn main() {
    let userAgent = userAgent_example; // String
    let targetYear = yyyy; // String

    let mut context = AllstarVoteApi::Context::default();
    let result = client.allstarVoteIndexApiGet(userAgent, targetYear, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Header parameters
Name Description
User-Agent
String
Query parameters
Name Description
target_year
String

Responses


AltairVote

altairVoteGet

altair_vote


/altair_vote

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/altair_vote?target_year=yyyy"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AltairVoteApi;

import java.io.File;
import java.util.*;

public class AltairVoteApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AltairVoteApi apiInstance = new AltairVoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.altairVoteGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling AltairVoteApi#altairVoteGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AltairVoteApi;

public class AltairVoteApiExample {
    public static void main(String[] args) {
        AltairVoteApi apiInstance = new AltairVoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.altairVoteGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling AltairVoteApi#altairVoteGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AltairVoteApi *apiInstance = [[AltairVoteApi alloc] init];
String *userAgent = userAgent_example; //  (optional) (default to null)
String *targetYear = yyyy; //  (optional) (default to null)

// altair_vote
[apiInstance altairVoteGetWith:userAgent
    targetYear:targetYear
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AltairVoteApi()
var opts = {
  'userAgent': userAgent_example, // {String} 
  'targetYear': yyyy // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.altairVoteGet(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class altairVoteGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AltairVoteApi();
            var userAgent = userAgent_example;  // String |  (optional)  (default to null)
            var targetYear = yyyy;  // String |  (optional)  (default to null)

            try {
                // altair_vote
                apiInstance.altairVoteGet(userAgent, targetYear);
            } catch (Exception e) {
                Debug.Print("Exception when calling AltairVoteApi.altairVoteGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AltairVoteApi();
$userAgent = userAgent_example; // String | 
$targetYear = yyyy; // String | 

try {
    $api_instance->altairVoteGet($userAgent, $targetYear);
} catch (Exception $e) {
    echo 'Exception when calling AltairVoteApi->altairVoteGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AltairVoteApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AltairVoteApi->new();
my $userAgent = userAgent_example; # String | 
my $targetYear = yyyy; # String | 

eval {
    $api_instance->altairVoteGet(userAgent => $userAgent, targetYear => $targetYear);
};
if ($@) {
    warn "Exception when calling AltairVoteApi->altairVoteGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AltairVoteApi()
userAgent = userAgent_example # String |  (optional) (default to null)
targetYear = yyyy # String |  (optional) (default to null)

try:
    # altair_vote
    api_instance.altair_vote_get(userAgent=userAgent, targetYear=targetYear)
except ApiException as e:
    print("Exception when calling AltairVoteApi->altairVoteGet: %s\n" % e)
extern crate AltairVoteApi;

pub fn main() {
    let userAgent = userAgent_example; // String
    let targetYear = yyyy; // String

    let mut context = AltairVoteApi::Context::default();
    let result = client.altairVoteGet(userAgent, targetYear, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Header parameters
Name Description
User-Agent
String
Query parameters
Name Description
target_year
String

Responses


altairVoteIndexApiGet

altair_vote/index_api


/altair_vote/index_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/altair_vote/index_api?target_year=yyyy"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AltairVoteApi;

import java.io.File;
import java.util.*;

public class AltairVoteApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        AltairVoteApi apiInstance = new AltairVoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.altairVoteIndexApiGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling AltairVoteApi#altairVoteIndexApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AltairVoteApi;

public class AltairVoteApiExample {
    public static void main(String[] args) {
        AltairVoteApi apiInstance = new AltairVoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.altairVoteIndexApiGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling AltairVoteApi#altairVoteIndexApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
AltairVoteApi *apiInstance = [[AltairVoteApi alloc] init];
String *userAgent = userAgent_example; //  (optional) (default to null)
String *targetYear = yyyy; //  (optional) (default to null)

// altair_vote/index_api
[apiInstance altairVoteIndexApiGetWith:userAgent
    targetYear:targetYear
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.AltairVoteApi()
var opts = {
  'userAgent': userAgent_example, // {String} 
  'targetYear': yyyy // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.altairVoteIndexApiGet(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class altairVoteIndexApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new AltairVoteApi();
            var userAgent = userAgent_example;  // String |  (optional)  (default to null)
            var targetYear = yyyy;  // String |  (optional)  (default to null)

            try {
                // altair_vote/index_api
                apiInstance.altairVoteIndexApiGet(userAgent, targetYear);
            } catch (Exception e) {
                Debug.Print("Exception when calling AltairVoteApi.altairVoteIndexApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AltairVoteApi();
$userAgent = userAgent_example; // String | 
$targetYear = yyyy; // String | 

try {
    $api_instance->altairVoteIndexApiGet($userAgent, $targetYear);
} catch (Exception $e) {
    echo 'Exception when calling AltairVoteApi->altairVoteIndexApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AltairVoteApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AltairVoteApi->new();
my $userAgent = userAgent_example; # String | 
my $targetYear = yyyy; # String | 

eval {
    $api_instance->altairVoteIndexApiGet(userAgent => $userAgent, targetYear => $targetYear);
};
if ($@) {
    warn "Exception when calling AltairVoteApi->altairVoteIndexApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.AltairVoteApi()
userAgent = userAgent_example # String |  (optional) (default to null)
targetYear = yyyy # String |  (optional) (default to null)

try:
    # altair_vote/index_api
    api_instance.altair_vote_index_api_get(userAgent=userAgent, targetYear=targetYear)
except ApiException as e:
    print("Exception when calling AltairVoteApi->altairVoteIndexApiGet: %s\n" % e)
extern crate AltairVoteApi;

pub fn main() {
    let userAgent = userAgent_example; // String
    let targetYear = yyyy; // String

    let mut context = AltairVoteApi::Context::default();
    let result = client.altairVoteIndexApiGet(userAgent, targetYear, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Header parameters
Name Description
User-Agent
String
Query parameters
Name Description
target_year
String

Responses


BLeagueAuth

bLeagueAuthLinkAccountPost

link_account


/b_league_auth/link_account

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/b_league_auth/link_account" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.BLeagueAuthApi;

import java.io.File;
import java.util.*;

public class BLeagueAuthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        BLeagueAuthApi apiInstance = new BLeagueAuthApi();
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.bLeagueAuthLinkAccountPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BLeagueAuthApi#bLeagueAuthLinkAccountPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.BLeagueAuthApi;

public class BLeagueAuthApiExample {
    public static void main(String[] args) {
        BLeagueAuthApi apiInstance = new BLeagueAuthApi();
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.bLeagueAuthLinkAccountPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BLeagueAuthApi#bLeagueAuthLinkAccountPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
BLeagueAuthApi *apiInstance = [[BLeagueAuthApi alloc] init];
Object *body = Object; //  (optional)

// link_account
[apiInstance bLeagueAuthLinkAccountPostWith:body
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.BLeagueAuthApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.bLeagueAuthLinkAccountPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class bLeagueAuthLinkAccountPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new BLeagueAuthApi();
            var body = Object;  // Object |  (optional) 

            try {
                // link_account
                Object result = apiInstance.bLeagueAuthLinkAccountPost(body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BLeagueAuthApi.bLeagueAuthLinkAccountPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BLeagueAuthApi();
$body = Object; // Object | 

try {
    $result = $api_instance->bLeagueAuthLinkAccountPost($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BLeagueAuthApi->bLeagueAuthLinkAccountPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::BLeagueAuthApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BLeagueAuthApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    my $result = $api_instance->bLeagueAuthLinkAccountPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BLeagueAuthApi->bLeagueAuthLinkAccountPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.BLeagueAuthApi()
body = Object # Object |  (optional)

try:
    # link_account
    api_response = api_instance.b_league_auth_link_account_post(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BLeagueAuthApi->bLeagueAuthLinkAccountPost: %s\n" % e)
extern crate BLeagueAuthApi;

pub fn main() {
    let body = Object; // Object

    let mut context = BLeagueAuthApi::Context::default();
    let result = client.bLeagueAuthLinkAccountPost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses

Name Type Format Description
Date String
ContentMinusType String
TransferMinusEncoding String
Connection String
Server String
XMinusPoweredMinusBy BigDecimal
Expires String
CacheMinusControl String
Pragma String

Name Type Format Description
Date String
ContentMinusType String
TransferMinusEncoding String
Connection String
Server String
XMinusPoweredMinusBy BigDecimal
Expires String
CacheMinusControl String
Pragma String

bLeagueAuthLoginPost

login


/b_league_auth/login

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/b_league_auth/login" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.BLeagueAuthApi;

import java.io.File;
import java.util.*;

public class BLeagueAuthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        BLeagueAuthApi apiInstance = new BLeagueAuthApi();
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.bLeagueAuthLoginPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BLeagueAuthApi#bLeagueAuthLoginPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.BLeagueAuthApi;

public class BLeagueAuthApiExample {
    public static void main(String[] args) {
        BLeagueAuthApi apiInstance = new BLeagueAuthApi();
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.bLeagueAuthLoginPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BLeagueAuthApi#bLeagueAuthLoginPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
BLeagueAuthApi *apiInstance = [[BLeagueAuthApi alloc] init];
Object *body = Object; //  (optional)

// login
[apiInstance bLeagueAuthLoginPostWith:body
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.BLeagueAuthApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.bLeagueAuthLoginPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class bLeagueAuthLoginPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new BLeagueAuthApi();
            var body = Object;  // Object |  (optional) 

            try {
                // login
                Object result = apiInstance.bLeagueAuthLoginPost(body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BLeagueAuthApi.bLeagueAuthLoginPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BLeagueAuthApi();
$body = Object; // Object | 

try {
    $result = $api_instance->bLeagueAuthLoginPost($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BLeagueAuthApi->bLeagueAuthLoginPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::BLeagueAuthApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BLeagueAuthApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    my $result = $api_instance->bLeagueAuthLoginPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BLeagueAuthApi->bLeagueAuthLoginPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.BLeagueAuthApi()
body = Object # Object |  (optional)

try:
    # login
    api_response = api_instance.b_league_auth_login_post(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BLeagueAuthApi->bLeagueAuthLoginPost: %s\n" % e)
extern crate BLeagueAuthApi;

pub fn main() {
    let body = Object; // Object

    let mut context = BLeagueAuthApi::Context::default();
    let result = client.bLeagueAuthLoginPost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses

Name Type Format Description
Date String
ContentMinusType String
TransferMinusEncoding String
Connection String
Server String
XMinusPoweredMinusBy BigDecimal
Expires String
CacheMinusControl String
Pragma String

Name Type Format Description
Date String
ContentMinusType String
TransferMinusEncoding String
Connection String
Server String
XMinusPoweredMinusBy BigDecimal
Expires String
CacheMinusControl String
Pragma String

Name Type Format Description
Date String
ContentMinusType String
TransferMinusEncoding String
Connection String
Server String
XMinusPoweredMinusBy BigDecimal
Expires String
CacheMinusControl String
Pragma String

Campaign

campaignGet

campaign


/campaign

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/campaign"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignApi;

import java.io.File;
import java.util.*;

public class CampaignApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        CampaignApi apiInstance = new CampaignApi();

        try {
            apiInstance.campaignGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignApi#campaignGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.CampaignApi;

public class CampaignApiExample {
    public static void main(String[] args) {
        CampaignApi apiInstance = new CampaignApi();

        try {
            apiInstance.campaignGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignApi#campaignGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
CampaignApi *apiInstance = [[CampaignApi alloc] init];

// campaign
[apiInstance campaignGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.CampaignApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.campaignGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new CampaignApi();

            try {
                // campaign
                apiInstance.campaignGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignApi.campaignGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignApi();

try {
    $api_instance->campaignGet();
} catch (Exception $e) {
    echo 'Exception when calling CampaignApi->campaignGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignApi->new();

eval {
    $api_instance->campaignGet();
};
if ($@) {
    warn "Exception when calling CampaignApi->campaignGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.CampaignApi()

try:
    # campaign
    api_instance.campaign_get()
except ApiException as e:
    print("Exception when calling CampaignApi->campaignGet: %s\n" % e)
extern crate CampaignApi;

pub fn main() {

    let mut context = CampaignApi::Context::default();
    let result = client.campaignGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


campaignIndexApiGet

campaign/index_api


/campaign/index_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/campaign/index_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignApi;

import java.io.File;
import java.util.*;

public class CampaignApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        CampaignApi apiInstance = new CampaignApi();

        try {
            apiInstance.campaignIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignApi#campaignIndexApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.CampaignApi;

public class CampaignApiExample {
    public static void main(String[] args) {
        CampaignApi apiInstance = new CampaignApi();

        try {
            apiInstance.campaignIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignApi#campaignIndexApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
CampaignApi *apiInstance = [[CampaignApi alloc] init];

// campaign/index_api
[apiInstance campaignIndexApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.CampaignApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.campaignIndexApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignIndexApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new CampaignApi();

            try {
                // campaign/index_api
                apiInstance.campaignIndexApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignApi.campaignIndexApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignApi();

try {
    $api_instance->campaignIndexApiGet();
} catch (Exception $e) {
    echo 'Exception when calling CampaignApi->campaignIndexApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignApi->new();

eval {
    $api_instance->campaignIndexApiGet();
};
if ($@) {
    warn "Exception when calling CampaignApi->campaignIndexApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.CampaignApi()

try:
    # campaign/index_api
    api_instance.campaign_index_api_get()
except ApiException as e:
    print("Exception when calling CampaignApi->campaignIndexApiGet: %s\n" % e)
extern crate CampaignApi;

pub fn main() {

    let mut context = CampaignApi::Context::default();
    let result = client.campaignIndexApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


campaignToBackupApiGet

campaign/to_backup_api


/campaign/to_backup_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/campaign/to_backup_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignApi;

import java.io.File;
import java.util.*;

public class CampaignApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        CampaignApi apiInstance = new CampaignApi();

        try {
            apiInstance.campaignToBackupApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignApi#campaignToBackupApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.CampaignApi;

public class CampaignApiExample {
    public static void main(String[] args) {
        CampaignApi apiInstance = new CampaignApi();

        try {
            apiInstance.campaignToBackupApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignApi#campaignToBackupApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
CampaignApi *apiInstance = [[CampaignApi alloc] init];

// campaign/to_backup_api
[apiInstance campaignToBackupApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.CampaignApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.campaignToBackupApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignToBackupApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new CampaignApi();

            try {
                // campaign/to_backup_api
                apiInstance.campaignToBackupApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignApi.campaignToBackupApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignApi();

try {
    $api_instance->campaignToBackupApiGet();
} catch (Exception $e) {
    echo 'Exception when calling CampaignApi->campaignToBackupApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignApi->new();

eval {
    $api_instance->campaignToBackupApiGet();
};
if ($@) {
    warn "Exception when calling CampaignApi->campaignToBackupApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.CampaignApi()

try:
    # campaign/to_backup_api
    api_instance.campaign_to_backup_api_get()
except ApiException as e:
    print("Exception when calling CampaignApi->campaignToBackupApiGet: %s\n" % e)
extern crate CampaignApi;

pub fn main() {

    let mut context = CampaignApi::Context::default();
    let result = client.campaignToBackupApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


campaignToBackupGet

campaign/to_backup


/campaign/to_backup

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/campaign/to_backup"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignApi;

import java.io.File;
import java.util.*;

public class CampaignApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        CampaignApi apiInstance = new CampaignApi();

        try {
            apiInstance.campaignToBackupGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignApi#campaignToBackupGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.CampaignApi;

public class CampaignApiExample {
    public static void main(String[] args) {
        CampaignApi apiInstance = new CampaignApi();

        try {
            apiInstance.campaignToBackupGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignApi#campaignToBackupGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
CampaignApi *apiInstance = [[CampaignApi alloc] init];

// campaign/to_backup
[apiInstance campaignToBackupGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.CampaignApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.campaignToBackupGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignToBackupGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new CampaignApi();

            try {
                // campaign/to_backup
                apiInstance.campaignToBackupGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignApi.campaignToBackupGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignApi();

try {
    $api_instance->campaignToBackupGet();
} catch (Exception $e) {
    echo 'Exception when calling CampaignApi->campaignToBackupGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignApi->new();

eval {
    $api_instance->campaignToBackupGet();
};
if ($@) {
    warn "Exception when calling CampaignApi->campaignToBackupGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.CampaignApi()

try:
    # campaign/to_backup
    api_instance.campaign_to_backup_get()
except ApiException as e:
    print("Exception when calling CampaignApi->campaignToBackupGet: %s\n" % e)
extern crate CampaignApi;

pub fn main() {

    let mut context = CampaignApi::Context::default();
    let result = client.campaignToBackupGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


CardSeriesVote

cardSeriesVoteGet

card_series_vote


/card_series_vote

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/card_series_vote?target_year=yyyy"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CardSeriesVoteApi;

import java.io.File;
import java.util.*;

public class CardSeriesVoteApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        CardSeriesVoteApi apiInstance = new CardSeriesVoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.cardSeriesVoteGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling CardSeriesVoteApi#cardSeriesVoteGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.CardSeriesVoteApi;

public class CardSeriesVoteApiExample {
    public static void main(String[] args) {
        CardSeriesVoteApi apiInstance = new CardSeriesVoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.cardSeriesVoteGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling CardSeriesVoteApi#cardSeriesVoteGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
CardSeriesVoteApi *apiInstance = [[CardSeriesVoteApi alloc] init];
String *userAgent = userAgent_example; //  (optional) (default to null)
String *targetYear = yyyy; //  (optional) (default to null)

// card_series_vote
[apiInstance cardSeriesVoteGetWith:userAgent
    targetYear:targetYear
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.CardSeriesVoteApi()
var opts = {
  'userAgent': userAgent_example, // {String} 
  'targetYear': yyyy // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.cardSeriesVoteGet(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class cardSeriesVoteGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new CardSeriesVoteApi();
            var userAgent = userAgent_example;  // String |  (optional)  (default to null)
            var targetYear = yyyy;  // String |  (optional)  (default to null)

            try {
                // card_series_vote
                apiInstance.cardSeriesVoteGet(userAgent, targetYear);
            } catch (Exception e) {
                Debug.Print("Exception when calling CardSeriesVoteApi.cardSeriesVoteGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CardSeriesVoteApi();
$userAgent = userAgent_example; // String | 
$targetYear = yyyy; // String | 

try {
    $api_instance->cardSeriesVoteGet($userAgent, $targetYear);
} catch (Exception $e) {
    echo 'Exception when calling CardSeriesVoteApi->cardSeriesVoteGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CardSeriesVoteApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CardSeriesVoteApi->new();
my $userAgent = userAgent_example; # String | 
my $targetYear = yyyy; # String | 

eval {
    $api_instance->cardSeriesVoteGet(userAgent => $userAgent, targetYear => $targetYear);
};
if ($@) {
    warn "Exception when calling CardSeriesVoteApi->cardSeriesVoteGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.CardSeriesVoteApi()
userAgent = userAgent_example # String |  (optional) (default to null)
targetYear = yyyy # String |  (optional) (default to null)

try:
    # card_series_vote
    api_instance.card_series_vote_get(userAgent=userAgent, targetYear=targetYear)
except ApiException as e:
    print("Exception when calling CardSeriesVoteApi->cardSeriesVoteGet: %s\n" % e)
extern crate CardSeriesVoteApi;

pub fn main() {
    let userAgent = userAgent_example; // String
    let targetYear = yyyy; // String

    let mut context = CardSeriesVoteApi::Context::default();
    let result = client.cardSeriesVoteGet(userAgent, targetYear, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Header parameters
Name Description
User-Agent
String
Query parameters
Name Description
target_year
String

Responses


cardSeriesVoteIndexApiGet

card_series_vote/index_api


/card_series_vote/index_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/card_series_vote/index_api?target_year=yyyy"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CardSeriesVoteApi;

import java.io.File;
import java.util.*;

public class CardSeriesVoteApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        CardSeriesVoteApi apiInstance = new CardSeriesVoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.cardSeriesVoteIndexApiGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling CardSeriesVoteApi#cardSeriesVoteIndexApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.CardSeriesVoteApi;

public class CardSeriesVoteApiExample {
    public static void main(String[] args) {
        CardSeriesVoteApi apiInstance = new CardSeriesVoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.cardSeriesVoteIndexApiGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling CardSeriesVoteApi#cardSeriesVoteIndexApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
CardSeriesVoteApi *apiInstance = [[CardSeriesVoteApi alloc] init];
String *userAgent = userAgent_example; //  (optional) (default to null)
String *targetYear = yyyy; //  (optional) (default to null)

// card_series_vote/index_api
[apiInstance cardSeriesVoteIndexApiGetWith:userAgent
    targetYear:targetYear
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.CardSeriesVoteApi()
var opts = {
  'userAgent': userAgent_example, // {String} 
  'targetYear': yyyy // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.cardSeriesVoteIndexApiGet(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class cardSeriesVoteIndexApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new CardSeriesVoteApi();
            var userAgent = userAgent_example;  // String |  (optional)  (default to null)
            var targetYear = yyyy;  // String |  (optional)  (default to null)

            try {
                // card_series_vote/index_api
                apiInstance.cardSeriesVoteIndexApiGet(userAgent, targetYear);
            } catch (Exception e) {
                Debug.Print("Exception when calling CardSeriesVoteApi.cardSeriesVoteIndexApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CardSeriesVoteApi();
$userAgent = userAgent_example; // String | 
$targetYear = yyyy; // String | 

try {
    $api_instance->cardSeriesVoteIndexApiGet($userAgent, $targetYear);
} catch (Exception $e) {
    echo 'Exception when calling CardSeriesVoteApi->cardSeriesVoteIndexApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CardSeriesVoteApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CardSeriesVoteApi->new();
my $userAgent = userAgent_example; # String | 
my $targetYear = yyyy; # String | 

eval {
    $api_instance->cardSeriesVoteIndexApiGet(userAgent => $userAgent, targetYear => $targetYear);
};
if ($@) {
    warn "Exception when calling CardSeriesVoteApi->cardSeriesVoteIndexApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.CardSeriesVoteApi()
userAgent = userAgent_example # String |  (optional) (default to null)
targetYear = yyyy # String |  (optional) (default to null)

try:
    # card_series_vote/index_api
    api_instance.card_series_vote_index_api_get(userAgent=userAgent, targetYear=targetYear)
except ApiException as e:
    print("Exception when calling CardSeriesVoteApi->cardSeriesVoteIndexApiGet: %s\n" % e)
extern crate CardSeriesVoteApi;

pub fn main() {
    let userAgent = userAgent_example; // String
    let targetYear = yyyy; // String

    let mut context = CardSeriesVoteApi::Context::default();
    let result = client.cardSeriesVoteIndexApiGet(userAgent, targetYear, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Header parameters
Name Description
User-Agent
String
Query parameters
Name Description
target_year
String

Responses


ClassMission

classMissionGet

class_mission


/class_mission

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/class_mission"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ClassMissionApi;

import java.io.File;
import java.util.*;

public class ClassMissionApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ClassMissionApi apiInstance = new ClassMissionApi();

        try {
            apiInstance.classMissionGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ClassMissionApi#classMissionGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ClassMissionApi;

public class ClassMissionApiExample {
    public static void main(String[] args) {
        ClassMissionApi apiInstance = new ClassMissionApi();

        try {
            apiInstance.classMissionGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ClassMissionApi#classMissionGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ClassMissionApi *apiInstance = [[ClassMissionApi alloc] init];

// class_mission
[apiInstance classMissionGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ClassMissionApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.classMissionGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class classMissionGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ClassMissionApi();

            try {
                // class_mission
                apiInstance.classMissionGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ClassMissionApi.classMissionGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ClassMissionApi();

try {
    $api_instance->classMissionGet();
} catch (Exception $e) {
    echo 'Exception when calling ClassMissionApi->classMissionGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ClassMissionApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ClassMissionApi->new();

eval {
    $api_instance->classMissionGet();
};
if ($@) {
    warn "Exception when calling ClassMissionApi->classMissionGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ClassMissionApi()

try:
    # class_mission
    api_instance.class_mission_get()
except ApiException as e:
    print("Exception when calling ClassMissionApi->classMissionGet: %s\n" % e)
extern crate ClassMissionApi;

pub fn main() {

    let mut context = ClassMissionApi::Context::default();
    let result = client.classMissionGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


classMissionIndexApiGet

class_mission/index_api


/class_mission/index_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/class_mission/index_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ClassMissionApi;

import java.io.File;
import java.util.*;

public class ClassMissionApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ClassMissionApi apiInstance = new ClassMissionApi();

        try {
            apiInstance.classMissionIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ClassMissionApi#classMissionIndexApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ClassMissionApi;

public class ClassMissionApiExample {
    public static void main(String[] args) {
        ClassMissionApi apiInstance = new ClassMissionApi();

        try {
            apiInstance.classMissionIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ClassMissionApi#classMissionIndexApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ClassMissionApi *apiInstance = [[ClassMissionApi alloc] init];

// class_mission/index_api
[apiInstance classMissionIndexApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ClassMissionApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.classMissionIndexApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class classMissionIndexApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ClassMissionApi();

            try {
                // class_mission/index_api
                apiInstance.classMissionIndexApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ClassMissionApi.classMissionIndexApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ClassMissionApi();

try {
    $api_instance->classMissionIndexApiGet();
} catch (Exception $e) {
    echo 'Exception when calling ClassMissionApi->classMissionIndexApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ClassMissionApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ClassMissionApi->new();

eval {
    $api_instance->classMissionIndexApiGet();
};
if ($@) {
    warn "Exception when calling ClassMissionApi->classMissionIndexApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ClassMissionApi()

try:
    # class_mission/index_api
    api_instance.class_mission_index_api_get()
except ApiException as e:
    print("Exception when calling ClassMissionApi->classMissionIndexApiGet: %s\n" % e)
extern crate ClassMissionApi;

pub fn main() {

    let mut context = ClassMissionApi::Context::default();
    let result = client.classMissionIndexApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


Dreamteam

dreamteamGet

dreamteam


/dreamteam

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/dreamteam?target_year=yyyy"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DreamteamApi;

import java.io.File;
import java.util.*;

public class DreamteamApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        DreamteamApi apiInstance = new DreamteamApi();
        String targetYear = yyyy; // String | yyyy年のドリームチーム、デフォルト値(今年の)

        try {
            apiInstance.dreamteamGet(targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling DreamteamApi#dreamteamGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DreamteamApi;

public class DreamteamApiExample {
    public static void main(String[] args) {
        DreamteamApi apiInstance = new DreamteamApi();
        String targetYear = yyyy; // String | yyyy年のドリームチーム、デフォルト値(今年の)

        try {
            apiInstance.dreamteamGet(targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling DreamteamApi#dreamteamGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
DreamteamApi *apiInstance = [[DreamteamApi alloc] init];
String *targetYear = yyyy; // yyyy年のドリームチーム、デフォルト値(今年の) (optional) (default to null)

// dreamteam
[apiInstance dreamteamGetWith:targetYear
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.DreamteamApi()
var opts = {
  'targetYear': yyyy // {String} yyyy年のドリームチーム、デフォルト値(今年の)
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.dreamteamGet(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class dreamteamGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new DreamteamApi();
            var targetYear = yyyy;  // String | yyyy年のドリームチーム、デフォルト値(今年の) (optional)  (default to null)

            try {
                // dreamteam
                apiInstance.dreamteamGet(targetYear);
            } catch (Exception e) {
                Debug.Print("Exception when calling DreamteamApi.dreamteamGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DreamteamApi();
$targetYear = yyyy; // String | yyyy年のドリームチーム、デフォルト値(今年の)

try {
    $api_instance->dreamteamGet($targetYear);
} catch (Exception $e) {
    echo 'Exception when calling DreamteamApi->dreamteamGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DreamteamApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DreamteamApi->new();
my $targetYear = yyyy; # String | yyyy年のドリームチーム、デフォルト値(今年の)

eval {
    $api_instance->dreamteamGet(targetYear => $targetYear);
};
if ($@) {
    warn "Exception when calling DreamteamApi->dreamteamGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.DreamteamApi()
targetYear = yyyy # String | yyyy年のドリームチーム、デフォルト値(今年の) (optional) (default to null)

try:
    # dreamteam
    api_instance.dreamteam_get(targetYear=targetYear)
except ApiException as e:
    print("Exception when calling DreamteamApi->dreamteamGet: %s\n" % e)
extern crate DreamteamApi;

pub fn main() {
    let targetYear = yyyy; // String

    let mut context = DreamteamApi::Context::default();
    let result = client.dreamteamGet(targetYear, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
target_year
String
yyyy年のドリームチーム、デフォルト値(今年の)

Responses


dreamteamIndexApiGet

dreamteam/index_api


/dreamteam/index_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/dreamteam/index_api?target_year=yyyy"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DreamteamApi;

import java.io.File;
import java.util.*;

public class DreamteamApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        DreamteamApi apiInstance = new DreamteamApi();
        String targetYear = yyyy; // String | 

        try {
            apiInstance.dreamteamIndexApiGet(targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling DreamteamApi#dreamteamIndexApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DreamteamApi;

public class DreamteamApiExample {
    public static void main(String[] args) {
        DreamteamApi apiInstance = new DreamteamApi();
        String targetYear = yyyy; // String | 

        try {
            apiInstance.dreamteamIndexApiGet(targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling DreamteamApi#dreamteamIndexApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
DreamteamApi *apiInstance = [[DreamteamApi alloc] init];
String *targetYear = yyyy; //  (optional) (default to null)

// dreamteam/index_api
[apiInstance dreamteamIndexApiGetWith:targetYear
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.DreamteamApi()
var opts = {
  'targetYear': yyyy // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.dreamteamIndexApiGet(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class dreamteamIndexApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new DreamteamApi();
            var targetYear = yyyy;  // String |  (optional)  (default to null)

            try {
                // dreamteam/index_api
                apiInstance.dreamteamIndexApiGet(targetYear);
            } catch (Exception e) {
                Debug.Print("Exception when calling DreamteamApi.dreamteamIndexApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DreamteamApi();
$targetYear = yyyy; // String | 

try {
    $api_instance->dreamteamIndexApiGet($targetYear);
} catch (Exception $e) {
    echo 'Exception when calling DreamteamApi->dreamteamIndexApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DreamteamApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DreamteamApi->new();
my $targetYear = yyyy; # String | 

eval {
    $api_instance->dreamteamIndexApiGet(targetYear => $targetYear);
};
if ($@) {
    warn "Exception when calling DreamteamApi->dreamteamIndexApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.DreamteamApi()
targetYear = yyyy # String |  (optional) (default to null)

try:
    # dreamteam/index_api
    api_instance.dreamteam_index_api_get(targetYear=targetYear)
except ApiException as e:
    print("Exception when calling DreamteamApi->dreamteamIndexApiGet: %s\n" % e)
extern crate DreamteamApi;

pub fn main() {
    let targetYear = yyyy; // String

    let mut context = DreamteamApi::Context::default();
    let result = client.dreamteamIndexApiGet(targetYear, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
target_year
String

Responses


DreamteamVote

dreamteamVoteB1Get

dreamteam_vote/B1


/dreamteam_vote/B1

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/dreamteam_vote/B1"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DreamteamVoteApi;

import java.io.File;
import java.util.*;

public class DreamteamVoteApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        DreamteamVoteApi apiInstance = new DreamteamVoteApi();
        String userAgent = userAgent_example; // String | 

        try {
            apiInstance.dreamteamVoteB1Get(userAgent);
        } catch (ApiException e) {
            System.err.println("Exception when calling DreamteamVoteApi#dreamteamVoteB1Get");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DreamteamVoteApi;

public class DreamteamVoteApiExample {
    public static void main(String[] args) {
        DreamteamVoteApi apiInstance = new DreamteamVoteApi();
        String userAgent = userAgent_example; // String | 

        try {
            apiInstance.dreamteamVoteB1Get(userAgent);
        } catch (ApiException e) {
            System.err.println("Exception when calling DreamteamVoteApi#dreamteamVoteB1Get");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
DreamteamVoteApi *apiInstance = [[DreamteamVoteApi alloc] init];
String *userAgent = userAgent_example; //  (optional) (default to null)

// dreamteam_vote/B1
[apiInstance dreamteamVoteB1GetWith:userAgent
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.DreamteamVoteApi()
var opts = {
  'userAgent': userAgent_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.dreamteamVoteB1Get(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class dreamteamVoteB1GetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new DreamteamVoteApi();
            var userAgent = userAgent_example;  // String |  (optional)  (default to null)

            try {
                // dreamteam_vote/B1
                apiInstance.dreamteamVoteB1Get(userAgent);
            } catch (Exception e) {
                Debug.Print("Exception when calling DreamteamVoteApi.dreamteamVoteB1Get: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DreamteamVoteApi();
$userAgent = userAgent_example; // String | 

try {
    $api_instance->dreamteamVoteB1Get($userAgent);
} catch (Exception $e) {
    echo 'Exception when calling DreamteamVoteApi->dreamteamVoteB1Get: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DreamteamVoteApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DreamteamVoteApi->new();
my $userAgent = userAgent_example; # String | 

eval {
    $api_instance->dreamteamVoteB1Get(userAgent => $userAgent);
};
if ($@) {
    warn "Exception when calling DreamteamVoteApi->dreamteamVoteB1Get: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.DreamteamVoteApi()
userAgent = userAgent_example # String |  (optional) (default to null)

try:
    # dreamteam_vote/B1
    api_instance.dreamteam_vote_b1_get(userAgent=userAgent)
except ApiException as e:
    print("Exception when calling DreamteamVoteApi->dreamteamVoteB1Get: %s\n" % e)
extern crate DreamteamVoteApi;

pub fn main() {
    let userAgent = userAgent_example; // String

    let mut context = DreamteamVoteApi::Context::default();
    let result = client.dreamteamVoteB1Get(userAgent, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Header parameters
Name Description
User-Agent
String

Responses


dreamteamVoteB2Get

dreamteam_vote/B2


/dreamteam_vote/B2

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/dreamteam_vote/B2"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DreamteamVoteApi;

import java.io.File;
import java.util.*;

public class DreamteamVoteApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        DreamteamVoteApi apiInstance = new DreamteamVoteApi();
        String userAgent = userAgent_example; // String | 

        try {
            apiInstance.dreamteamVoteB2Get(userAgent);
        } catch (ApiException e) {
            System.err.println("Exception when calling DreamteamVoteApi#dreamteamVoteB2Get");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DreamteamVoteApi;

public class DreamteamVoteApiExample {
    public static void main(String[] args) {
        DreamteamVoteApi apiInstance = new DreamteamVoteApi();
        String userAgent = userAgent_example; // String | 

        try {
            apiInstance.dreamteamVoteB2Get(userAgent);
        } catch (ApiException e) {
            System.err.println("Exception when calling DreamteamVoteApi#dreamteamVoteB2Get");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
DreamteamVoteApi *apiInstance = [[DreamteamVoteApi alloc] init];
String *userAgent = userAgent_example; //  (optional) (default to null)

// dreamteam_vote/B2
[apiInstance dreamteamVoteB2GetWith:userAgent
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.DreamteamVoteApi()
var opts = {
  'userAgent': userAgent_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.dreamteamVoteB2Get(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class dreamteamVoteB2GetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new DreamteamVoteApi();
            var userAgent = userAgent_example;  // String |  (optional)  (default to null)

            try {
                // dreamteam_vote/B2
                apiInstance.dreamteamVoteB2Get(userAgent);
            } catch (Exception e) {
                Debug.Print("Exception when calling DreamteamVoteApi.dreamteamVoteB2Get: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DreamteamVoteApi();
$userAgent = userAgent_example; // String | 

try {
    $api_instance->dreamteamVoteB2Get($userAgent);
} catch (Exception $e) {
    echo 'Exception when calling DreamteamVoteApi->dreamteamVoteB2Get: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DreamteamVoteApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DreamteamVoteApi->new();
my $userAgent = userAgent_example; # String | 

eval {
    $api_instance->dreamteamVoteB2Get(userAgent => $userAgent);
};
if ($@) {
    warn "Exception when calling DreamteamVoteApi->dreamteamVoteB2Get: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.DreamteamVoteApi()
userAgent = userAgent_example # String |  (optional) (default to null)

try:
    # dreamteam_vote/B2
    api_instance.dreamteam_vote_b2_get(userAgent=userAgent)
except ApiException as e:
    print("Exception when calling DreamteamVoteApi->dreamteamVoteB2Get: %s\n" % e)
extern crate DreamteamVoteApi;

pub fn main() {
    let userAgent = userAgent_example; // String

    let mut context = DreamteamVoteApi::Context::default();
    let result = client.dreamteamVoteB2Get(userAgent, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Header parameters
Name Description
User-Agent
String

Responses


dreamteamVoteIndexApiGet

dreamteam_vote/index_api


/dreamteam_vote/index_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/dreamteam_vote/index_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DreamteamVoteApi;

import java.io.File;
import java.util.*;

public class DreamteamVoteApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        DreamteamVoteApi apiInstance = new DreamteamVoteApi();
        String userAgent = userAgent_example; // String | 

        try {
            apiInstance.dreamteamVoteIndexApiGet(userAgent);
        } catch (ApiException e) {
            System.err.println("Exception when calling DreamteamVoteApi#dreamteamVoteIndexApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DreamteamVoteApi;

public class DreamteamVoteApiExample {
    public static void main(String[] args) {
        DreamteamVoteApi apiInstance = new DreamteamVoteApi();
        String userAgent = userAgent_example; // String | 

        try {
            apiInstance.dreamteamVoteIndexApiGet(userAgent);
        } catch (ApiException e) {
            System.err.println("Exception when calling DreamteamVoteApi#dreamteamVoteIndexApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
DreamteamVoteApi *apiInstance = [[DreamteamVoteApi alloc] init];
String *userAgent = userAgent_example; //  (optional) (default to null)

// dreamteam_vote/index_api
[apiInstance dreamteamVoteIndexApiGetWith:userAgent
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.DreamteamVoteApi()
var opts = {
  'userAgent': userAgent_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.dreamteamVoteIndexApiGet(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class dreamteamVoteIndexApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new DreamteamVoteApi();
            var userAgent = userAgent_example;  // String |  (optional)  (default to null)

            try {
                // dreamteam_vote/index_api
                apiInstance.dreamteamVoteIndexApiGet(userAgent);
            } catch (Exception e) {
                Debug.Print("Exception when calling DreamteamVoteApi.dreamteamVoteIndexApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DreamteamVoteApi();
$userAgent = userAgent_example; // String | 

try {
    $api_instance->dreamteamVoteIndexApiGet($userAgent);
} catch (Exception $e) {
    echo 'Exception when calling DreamteamVoteApi->dreamteamVoteIndexApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DreamteamVoteApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DreamteamVoteApi->new();
my $userAgent = userAgent_example; # String | 

eval {
    $api_instance->dreamteamVoteIndexApiGet(userAgent => $userAgent);
};
if ($@) {
    warn "Exception when calling DreamteamVoteApi->dreamteamVoteIndexApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.DreamteamVoteApi()
userAgent = userAgent_example # String |  (optional) (default to null)

try:
    # dreamteam_vote/index_api
    api_instance.dreamteam_vote_index_api_get(userAgent=userAgent)
except ApiException as e:
    print("Exception when calling DreamteamVoteApi->dreamteamVoteIndexApiGet: %s\n" % e)
extern crate DreamteamVoteApi;

pub fn main() {
    let userAgent = userAgent_example; // String

    let mut context = DreamteamVoteApi::Context::default();
    let result = client.dreamteamVoteIndexApiGet(userAgent, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Header parameters
Name Description
User-Agent
String

Responses


Folder

folderApiGet

folder_api


/folder_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/folder_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.FolderApi;

import java.io.File;
import java.util.*;

public class FolderApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        FolderApi apiInstance = new FolderApi();

        try {
            apiInstance.folderApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling FolderApi#folderApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.FolderApi;

public class FolderApiExample {
    public static void main(String[] args) {
        FolderApi apiInstance = new FolderApi();

        try {
            apiInstance.folderApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling FolderApi#folderApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
FolderApi *apiInstance = [[FolderApi alloc] init];

// folder_api
[apiInstance folderApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.FolderApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.folderApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class folderApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new FolderApi();

            try {
                // folder_api
                apiInstance.folderApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling FolderApi.folderApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FolderApi();

try {
    $api_instance->folderApiGet();
} catch (Exception $e) {
    echo 'Exception when calling FolderApi->folderApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::FolderApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FolderApi->new();

eval {
    $api_instance->folderApiGet();
};
if ($@) {
    warn "Exception when calling FolderApi->folderApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.FolderApi()

try:
    # folder_api
    api_instance.folder_api_get()
except ApiException as e:
    print("Exception when calling FolderApi->folderApiGet: %s\n" % e)
extern crate FolderApi;

pub fn main() {

    let mut context = FolderApi::Context::default();
    let result = client.folderApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


folderGet

folder


/folder

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/folder"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.FolderApi;

import java.io.File;
import java.util.*;

public class FolderApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        FolderApi apiInstance = new FolderApi();

        try {
            apiInstance.folderGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling FolderApi#folderGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.FolderApi;

public class FolderApiExample {
    public static void main(String[] args) {
        FolderApi apiInstance = new FolderApi();

        try {
            apiInstance.folderGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling FolderApi#folderGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
FolderApi *apiInstance = [[FolderApi alloc] init];

// folder
[apiInstance folderGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.FolderApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.folderGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class folderGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new FolderApi();

            try {
                // folder
                apiInstance.folderGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling FolderApi.folderGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FolderApi();

try {
    $api_instance->folderGet();
} catch (Exception $e) {
    echo 'Exception when calling FolderApi->folderGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::FolderApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FolderApi->new();

eval {
    $api_instance->folderGet();
};
if ($@) {
    warn "Exception when calling FolderApi->folderGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.FolderApi()

try:
    # folder
    api_instance.folder_get()
except ApiException as e:
    print("Exception when calling FolderApi->folderGet: %s\n" % e)
extern crate FolderApi;

pub fn main() {

    let mut context = FolderApi::Context::default();
    let result = client.folderGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


Forecast

forecastBasicApiGet

forecast/basic_api


/forecast/basic_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/forecast/basic_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastBasicApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastBasicApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastBasicApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastBasicApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];

// forecast/basic_api
[apiInstance forecastBasicApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastBasicApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastBasicApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();

            try {
                // forecast/basic_api
                apiInstance.forecastBasicApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastBasicApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();

try {
    $api_instance->forecastBasicApiGet();
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastBasicApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();

eval {
    $api_instance->forecastBasicApiGet();
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastBasicApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()

try:
    # forecast/basic_api
    api_instance.forecast_basic_api_get()
except ApiException as e:
    print("Exception when calling ForecastApi->forecastBasicApiGet: %s\n" % e)
extern crate ForecastApi;

pub fn main() {

    let mut context = ForecastApi::Context::default();
    let result = client.forecastBasicApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


forecastBasicGet

forecast/basic


/forecast/basic

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/forecast/basic"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastBasicGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastBasicGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastBasicGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastBasicGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];

// forecast/basic
[apiInstance forecastBasicGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastBasicGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastBasicGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();

            try {
                // forecast/basic
                apiInstance.forecastBasicGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastBasicGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();

try {
    $api_instance->forecastBasicGet();
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastBasicGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();

eval {
    $api_instance->forecastBasicGet();
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastBasicGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()

try:
    # forecast/basic
    api_instance.forecast_basic_get()
except ApiException as e:
    print("Exception when calling ForecastApi->forecastBasicGet: %s\n" % e)
extern crate ForecastApi;

pub fn main() {

    let mut context = ForecastApi::Context::default();
    let result = client.forecastBasicGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


forecastBonusDetailApiGet

forecast/bonus_detail_api


/forecast/bonus_detail_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/forecast/bonus_detail_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastBonusDetailApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastBonusDetailApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastBonusDetailApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastBonusDetailApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];

// forecast/bonus_detail_api
[apiInstance forecastBonusDetailApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastBonusDetailApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastBonusDetailApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();

            try {
                // forecast/bonus_detail_api
                apiInstance.forecastBonusDetailApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastBonusDetailApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();

try {
    $api_instance->forecastBonusDetailApiGet();
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastBonusDetailApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();

eval {
    $api_instance->forecastBonusDetailApiGet();
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastBonusDetailApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()

try:
    # forecast/bonus_detail_api
    api_instance.forecast_bonus_detail_api_get()
except ApiException as e:
    print("Exception when calling ForecastApi->forecastBonusDetailApiGet: %s\n" % e)
extern crate ForecastApi;

pub fn main() {

    let mut context = ForecastApi::Context::default();
    let result = client.forecastBonusDetailApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


forecastBonusDetailGet

forecast/bonus_detail


/forecast/bonus_detail

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/forecast/bonus_detail"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastBonusDetailGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastBonusDetailGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastBonusDetailGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastBonusDetailGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];

// forecast/bonus_detail
[apiInstance forecastBonusDetailGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastBonusDetailGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastBonusDetailGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();

            try {
                // forecast/bonus_detail
                apiInstance.forecastBonusDetailGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastBonusDetailGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();

try {
    $api_instance->forecastBonusDetailGet();
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastBonusDetailGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();

eval {
    $api_instance->forecastBonusDetailGet();
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastBonusDetailGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()

try:
    # forecast/bonus_detail
    api_instance.forecast_bonus_detail_get()
except ApiException as e:
    print("Exception when calling ForecastApi->forecastBonusDetailGet: %s\n" % e)
extern crate ForecastApi;

pub fn main() {

    let mut context = ForecastApi::Context::default();
    let result = client.forecastBonusDetailGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


forecastGet

forecast


/forecast/

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/forecast/"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];

// forecast
[apiInstance forecastGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();

            try {
                // forecast
                apiInstance.forecastGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();

try {
    $api_instance->forecastGet();
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();

eval {
    $api_instance->forecastGet();
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()

try:
    # forecast
    api_instance.forecast_get()
except ApiException as e:
    print("Exception when calling ForecastApi->forecastGet: %s\n" % e)
extern crate ForecastApi;

pub fn main() {

    let mut context = ForecastApi::Context::default();
    let result = client.forecastGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


forecastHistoryApiGet

forecast/history_api


/forecast/history_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/forecast/history_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastHistoryApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastHistoryApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastHistoryApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastHistoryApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];

// forecast/history_api
[apiInstance forecastHistoryApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastHistoryApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastHistoryApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();

            try {
                // forecast/history_api
                apiInstance.forecastHistoryApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastHistoryApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();

try {
    $api_instance->forecastHistoryApiGet();
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastHistoryApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();

eval {
    $api_instance->forecastHistoryApiGet();
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastHistoryApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()

try:
    # forecast/history_api
    api_instance.forecast_history_api_get()
except ApiException as e:
    print("Exception when calling ForecastApi->forecastHistoryApiGet: %s\n" % e)
extern crate ForecastApi;

pub fn main() {

    let mut context = ForecastApi::Context::default();
    let result = client.forecastHistoryApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


forecastHistoryDetailApiGet

forecast/history_detail_api


/forecast/history_detail_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/forecast/history_detail_api?section=1"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();
        Integer section = 1; // Integer | ${value}節のデータを取得する

        try {
            apiInstance.forecastHistoryDetailApiGet(section);
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastHistoryDetailApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();
        Integer section = 1; // Integer | ${value}節のデータを取得する

        try {
            apiInstance.forecastHistoryDetailApiGet(section);
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastHistoryDetailApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];
Integer *section = 1; // ${value}節のデータを取得する (optional) (default to null)

// forecast/history_detail_api
[apiInstance forecastHistoryDetailApiGetWith:section
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var opts = {
  'section': 1 // {Integer} ${value}節のデータを取得する
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastHistoryDetailApiGet(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastHistoryDetailApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();
            var section = 1;  // Integer | ${value}節のデータを取得する (optional)  (default to null)

            try {
                // forecast/history_detail_api
                apiInstance.forecastHistoryDetailApiGet(section);
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastHistoryDetailApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();
$section = 1; // Integer | ${value}節のデータを取得する

try {
    $api_instance->forecastHistoryDetailApiGet($section);
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastHistoryDetailApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();
my $section = 1; # Integer | ${value}節のデータを取得する

eval {
    $api_instance->forecastHistoryDetailApiGet(section => $section);
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastHistoryDetailApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()
section = 1 # Integer | ${value}節のデータを取得する (optional) (default to null)

try:
    # forecast/history_detail_api
    api_instance.forecast_history_detail_api_get(section=section)
except ApiException as e:
    print("Exception when calling ForecastApi->forecastHistoryDetailApiGet: %s\n" % e)
extern crate ForecastApi;

pub fn main() {
    let section = 1; // Integer

    let mut context = ForecastApi::Context::default();
    let result = client.forecastHistoryDetailApiGet(section, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
section
Integer
${value}節のデータを取得する

Responses


forecastHistoryDetailGet

forecast/history_detail


/forecast/history_detail

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/forecast/history_detail?section=1"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();
        Integer section = 1; // Integer | ${value}節のデータを取得する

        try {
            apiInstance.forecastHistoryDetailGet(section);
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastHistoryDetailGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();
        Integer section = 1; // Integer | ${value}節のデータを取得する

        try {
            apiInstance.forecastHistoryDetailGet(section);
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastHistoryDetailGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];
Integer *section = 1; // ${value}節のデータを取得する (optional) (default to null)

// forecast/history_detail
[apiInstance forecastHistoryDetailGetWith:section
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var opts = {
  'section': 1 // {Integer} ${value}節のデータを取得する
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastHistoryDetailGet(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastHistoryDetailGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();
            var section = 1;  // Integer | ${value}節のデータを取得する (optional)  (default to null)

            try {
                // forecast/history_detail
                apiInstance.forecastHistoryDetailGet(section);
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastHistoryDetailGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();
$section = 1; // Integer | ${value}節のデータを取得する

try {
    $api_instance->forecastHistoryDetailGet($section);
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastHistoryDetailGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();
my $section = 1; # Integer | ${value}節のデータを取得する

eval {
    $api_instance->forecastHistoryDetailGet(section => $section);
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastHistoryDetailGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()
section = 1 # Integer | ${value}節のデータを取得する (optional) (default to null)

try:
    # forecast/history_detail
    api_instance.forecast_history_detail_get(section=section)
except ApiException as e:
    print("Exception when calling ForecastApi->forecastHistoryDetailGet: %s\n" % e)
extern crate ForecastApi;

pub fn main() {
    let section = 1; // Integer

    let mut context = ForecastApi::Context::default();
    let result = client.forecastHistoryDetailGet(section, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
section
Integer
${value}節のデータを取得する

Responses


forecastHistoryGet

forecast/history


/forecast/history

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/forecast/history"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastHistoryGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastHistoryGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastHistoryGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastHistoryGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];

// forecast/history
[apiInstance forecastHistoryGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastHistoryGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastHistoryGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();

            try {
                // forecast/history
                apiInstance.forecastHistoryGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastHistoryGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();

try {
    $api_instance->forecastHistoryGet();
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastHistoryGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();

eval {
    $api_instance->forecastHistoryGet();
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastHistoryGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()

try:
    # forecast/history
    api_instance.forecast_history_get()
except ApiException as e:
    print("Exception when calling ForecastApi->forecastHistoryGet: %s\n" % e)
extern crate ForecastApi;

pub fn main() {

    let mut context = ForecastApi::Context::default();
    let result = client.forecastHistoryGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


forecastIndexApiGet

forecast/index_api


/forecast/index_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/forecast/index_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastIndexApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastIndexApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];

// forecast/index_api
[apiInstance forecastIndexApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastIndexApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastIndexApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();

            try {
                // forecast/index_api
                apiInstance.forecastIndexApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastIndexApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();

try {
    $api_instance->forecastIndexApiGet();
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastIndexApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();

eval {
    $api_instance->forecastIndexApiGet();
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastIndexApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()

try:
    # forecast/index_api
    api_instance.forecast_index_api_get()
except ApiException as e:
    print("Exception when calling ForecastApi->forecastIndexApiGet: %s\n" % e)
extern crate ForecastApi;

pub fn main() {

    let mut context = ForecastApi::Context::default();
    let result = client.forecastIndexApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


forecastRankingApiGet

forecast/ranking_api


/forecast/ranking_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/forecast/ranking_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastRankingApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastRankingApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastRankingApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastRankingApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];

// forecast/ranking_api
[apiInstance forecastRankingApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastRankingApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastRankingApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();

            try {
                // forecast/ranking_api
                apiInstance.forecastRankingApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastRankingApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();

try {
    $api_instance->forecastRankingApiGet();
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastRankingApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();

eval {
    $api_instance->forecastRankingApiGet();
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastRankingApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()

try:
    # forecast/ranking_api
    api_instance.forecast_ranking_api_get()
except ApiException as e:
    print("Exception when calling ForecastApi->forecastRankingApiGet: %s\n" % e)
extern crate ForecastApi;

pub fn main() {

    let mut context = ForecastApi::Context::default();
    let result = client.forecastRankingApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


forecastRankingGet

forecast/ranking


/forecast/ranking

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/forecast/ranking"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastRankingGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastRankingGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastRankingGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastRankingGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];

// forecast/ranking
[apiInstance forecastRankingGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastRankingGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastRankingGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();

            try {
                // forecast/ranking
                apiInstance.forecastRankingGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastRankingGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();

try {
    $api_instance->forecastRankingGet();
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastRankingGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();

eval {
    $api_instance->forecastRankingGet();
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastRankingGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()

try:
    # forecast/ranking
    api_instance.forecast_ranking_get()
except ApiException as e:
    print("Exception when calling ForecastApi->forecastRankingGet: %s\n" % e)
extern crate ForecastApi;

pub fn main() {

    let mut context = ForecastApi::Context::default();
    let result = client.forecastRankingGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


forecastResultEffectApiGet

forecast/result_effect_api


/forecast/result_effect_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/forecast/result_effect_api?r=b"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();
        String r = b; // String | 

        try {
            Object result = apiInstance.forecastResultEffectApiGet(r);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastResultEffectApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();
        String r = b; // String | 

        try {
            Object result = apiInstance.forecastResultEffectApiGet(r);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastResultEffectApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];
String *r = b; //  (optional) (default to null)

// forecast/result_effect_api
[apiInstance forecastResultEffectApiGetWith:r
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var opts = {
  'r': b // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.forecastResultEffectApiGet(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastResultEffectApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();
            var r = b;  // String |  (optional)  (default to null)

            try {
                // forecast/result_effect_api
                Object result = apiInstance.forecastResultEffectApiGet(r);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastResultEffectApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();
$r = b; // String | 

try {
    $result = $api_instance->forecastResultEffectApiGet($r);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastResultEffectApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();
my $r = b; # String | 

eval {
    my $result = $api_instance->forecastResultEffectApiGet(r => $r);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastResultEffectApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()
r = b # String |  (optional) (default to null)

try:
    # forecast/result_effect_api
    api_response = api_instance.forecast_result_effect_api_get(r=r)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ForecastApi->forecastResultEffectApiGet: %s\n" % e)
extern crate ForecastApi;

pub fn main() {
    let r = b; // String

    let mut context = ForecastApi::Context::default();
    let result = client.forecastResultEffectApiGet(r, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
r
String

Responses

Name Type Format Description
Date String
ContentMinusType String
TransferMinusEncoding String
Connection String
Server String
XMinusPoweredMinusBy BigDecimal
Expires String
CacheMinusControl String
Pragma String

forecastResultEffectGet

forecast/result_effect


/forecast/result_effect

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/forecast/result_effect?r=b"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();
        String r = b; // String | 

        try {
            apiInstance.forecastResultEffectGet(r);
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastResultEffectGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();
        String r = b; // String | 

        try {
            apiInstance.forecastResultEffectGet(r);
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastResultEffectGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];
String *r = b; //  (optional) (default to null)

// forecast/result_effect
[apiInstance forecastResultEffectGetWith:r
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var opts = {
  'r': b // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastResultEffectGet(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastResultEffectGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();
            var r = b;  // String |  (optional)  (default to null)

            try {
                // forecast/result_effect
                apiInstance.forecastResultEffectGet(r);
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastResultEffectGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();
$r = b; // String | 

try {
    $api_instance->forecastResultEffectGet($r);
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastResultEffectGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();
my $r = b; # String | 

eval {
    $api_instance->forecastResultEffectGet(r => $r);
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastResultEffectGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()
r = b # String |  (optional) (default to null)

try:
    # forecast/result_effect
    api_instance.forecast_result_effect_get(r=r)
except ApiException as e:
    print("Exception when calling ForecastApi->forecastResultEffectGet: %s\n" % e)
extern crate ForecastApi;

pub fn main() {
    let r = b; // String

    let mut context = ForecastApi::Context::default();
    let result = client.forecastResultEffectGet(r, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
r
String

Responses


forecastRewardApiGet

forecast/reward_api


/forecast/reward_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/forecast/reward_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastRewardApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastRewardApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastRewardApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastRewardApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];

// forecast/reward_api
[apiInstance forecastRewardApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastRewardApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastRewardApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();

            try {
                // forecast/reward_api
                apiInstance.forecastRewardApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastRewardApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();

try {
    $api_instance->forecastRewardApiGet();
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastRewardApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();

eval {
    $api_instance->forecastRewardApiGet();
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastRewardApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()

try:
    # forecast/reward_api
    api_instance.forecast_reward_api_get()
except ApiException as e:
    print("Exception when calling ForecastApi->forecastRewardApiGet: %s\n" % e)
extern crate ForecastApi;

pub fn main() {

    let mut context = ForecastApi::Context::default();
    let result = client.forecastRewardApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


forecastRewardGet

forecast/reward


/forecast/reward

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/forecast/reward"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastRewardGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastRewardGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastRewardGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastRewardGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];

// forecast/reward
[apiInstance forecastRewardGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastRewardGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastRewardGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();

            try {
                // forecast/reward
                apiInstance.forecastRewardGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastRewardGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();

try {
    $api_instance->forecastRewardGet();
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastRewardGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();

eval {
    $api_instance->forecastRewardGet();
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastRewardGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()

try:
    # forecast/reward
    api_instance.forecast_reward_get()
except ApiException as e:
    print("Exception when calling ForecastApi->forecastRewardGet: %s\n" % e)
extern crate ForecastApi;

pub fn main() {

    let mut context = ForecastApi::Context::default();
    let result = client.forecastRewardGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


forecastScoreDetailApiGet

forecast/score_detail_api


/forecast/score_detail_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/forecast/score_detail_api?slot=3§ion=21"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();
        Integer slot = 3; // Integer | 
        Integer section = 21; // Integer | 節

        try {
            Object result = apiInstance.forecastScoreDetailApiGet(slot, section);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastScoreDetailApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();
        Integer slot = 3; // Integer | 
        Integer section = 21; // Integer | 節

        try {
            Object result = apiInstance.forecastScoreDetailApiGet(slot, section);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastScoreDetailApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];
Integer *slot = 3; //  (optional) (default to null)
Integer *section = 21; // 節 (optional) (default to null)

// forecast/score_detail_api
[apiInstance forecastScoreDetailApiGetWith:slot
    section:section
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var opts = {
  'slot': 3, // {Integer} 
  'section': 21 // {Integer} 節
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.forecastScoreDetailApiGet(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastScoreDetailApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();
            var slot = 3;  // Integer |  (optional)  (default to null)
            var section = 21;  // Integer | 節 (optional)  (default to null)

            try {
                // forecast/score_detail_api
                Object result = apiInstance.forecastScoreDetailApiGet(slot, section);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastScoreDetailApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();
$slot = 3; // Integer | 
$section = 21; // Integer | 節

try {
    $result = $api_instance->forecastScoreDetailApiGet($slot, $section);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastScoreDetailApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();
my $slot = 3; # Integer | 
my $section = 21; # Integer | 節

eval {
    my $result = $api_instance->forecastScoreDetailApiGet(slot => $slot, section => $section);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastScoreDetailApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()
slot = 3 # Integer |  (optional) (default to null)
section = 21 # Integer | 節 (optional) (default to null)

try:
    # forecast/score_detail_api
    api_response = api_instance.forecast_score_detail_api_get(slot=slot, section=section)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ForecastApi->forecastScoreDetailApiGet: %s\n" % e)
extern crate ForecastApi;

pub fn main() {
    let slot = 3; // Integer
    let section = 21; // Integer

    let mut context = ForecastApi::Context::default();
    let result = client.forecastScoreDetailApiGet(slot, section, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
slot
Integer
section
Integer

Responses

Name Type Format Description
Date String
ContentMinusType String
TransferMinusEncoding String
Connection String
Server String
XMinusPoweredMinusBy BigDecimal
Expires String
CacheMinusControl String
Pragma String

forecastScoreDetailGet

forecast/score_detail


/forecast/score_detail

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/forecast/score_detail??slot=3§ion=21"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();
        Integer Question_Markslot = 3; // Integer | 
        Integer section = 21; // Integer | 節

        try {
            apiInstance.forecastScoreDetailGet(Question_Markslot, section);
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastScoreDetailGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();
        Integer Question_Markslot = 3; // Integer | 
        Integer section = 21; // Integer | 節

        try {
            apiInstance.forecastScoreDetailGet(Question_Markslot, section);
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastScoreDetailGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];
Integer *Question_Markslot = 3; //  (optional) (default to null)
Integer *section = 21; // 節 (optional) (default to null)

// forecast/score_detail
[apiInstance forecastScoreDetailGetWith:Question_Markslot
    section:section
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var opts = {
  'Question_Markslot': 3, // {Integer} 
  'section': 21 // {Integer} 節
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastScoreDetailGet(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastScoreDetailGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();
            var Question_Markslot = 3;  // Integer |  (optional)  (default to null)
            var section = 21;  // Integer | 節 (optional)  (default to null)

            try {
                // forecast/score_detail
                apiInstance.forecastScoreDetailGet(Question_Markslot, section);
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastScoreDetailGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();
$Question_Markslot = 3; // Integer | 
$section = 21; // Integer | 節

try {
    $api_instance->forecastScoreDetailGet($Question_Markslot, $section);
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastScoreDetailGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();
my $Question_Markslot = 3; # Integer | 
my $section = 21; # Integer | 節

eval {
    $api_instance->forecastScoreDetailGet(Question_Markslot => $Question_Markslot, section => $section);
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastScoreDetailGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()
Question_Markslot = 3 # Integer |  (optional) (default to null)
section = 21 # Integer | 節 (optional) (default to null)

try:
    # forecast/score_detail
    api_instance.forecast_score_detail_get(Question_Markslot=Question_Markslot, section=section)
except ApiException as e:
    print("Exception when calling ForecastApi->forecastScoreDetailGet: %s\n" % e)
extern crate ForecastApi;

pub fn main() {
    let Question_Markslot = 3; // Integer
    let section = 21; // Integer

    let mut context = ForecastApi::Context::default();
    let result = client.forecastScoreDetailGet(Question_Markslot, section, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
?slot
Integer
section
Integer

Responses


forecastScoreListApiGet

forecast/score_list_api


/forecast/score_list_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/forecast/score_list_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastScoreListApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastScoreListApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastScoreListApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastScoreListApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];

// forecast/score_list_api
[apiInstance forecastScoreListApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastScoreListApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastScoreListApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();

            try {
                // forecast/score_list_api
                apiInstance.forecastScoreListApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastScoreListApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();

try {
    $api_instance->forecastScoreListApiGet();
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastScoreListApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();

eval {
    $api_instance->forecastScoreListApiGet();
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastScoreListApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()

try:
    # forecast/score_list_api
    api_instance.forecast_score_list_api_get()
except ApiException as e:
    print("Exception when calling ForecastApi->forecastScoreListApiGet: %s\n" % e)
extern crate ForecastApi;

pub fn main() {

    let mut context = ForecastApi::Context::default();
    let result = client.forecastScoreListApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


forecastScoreListGet

forecast/score_list


/forecast/score_list

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/forecast/score_list"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastScoreListGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastScoreListGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastScoreListGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastScoreListGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];

// forecast/score_list
[apiInstance forecastScoreListGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastScoreListGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastScoreListGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();

            try {
                // forecast/score_list
                apiInstance.forecastScoreListGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastScoreListGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();

try {
    $api_instance->forecastScoreListGet();
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastScoreListGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();

eval {
    $api_instance->forecastScoreListGet();
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastScoreListGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()

try:
    # forecast/score_list
    api_instance.forecast_score_list_get()
except ApiException as e:
    print("Exception when calling ForecastApi->forecastScoreListGet: %s\n" % e)
extern crate ForecastApi;

pub fn main() {

    let mut context = ForecastApi::Context::default();
    let result = client.forecastScoreListGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


forecastSeasonRankingApiGet

forecast/season_ranking_api


/forecast/season_ranking_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/forecast/season_ranking_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastSeasonRankingApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastSeasonRankingApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastSeasonRankingApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastSeasonRankingApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];

// forecast/season_ranking_api
[apiInstance forecastSeasonRankingApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastSeasonRankingApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastSeasonRankingApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();

            try {
                // forecast/season_ranking_api
                apiInstance.forecastSeasonRankingApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastSeasonRankingApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();

try {
    $api_instance->forecastSeasonRankingApiGet();
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastSeasonRankingApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();

eval {
    $api_instance->forecastSeasonRankingApiGet();
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastSeasonRankingApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()

try:
    # forecast/season_ranking_api
    api_instance.forecast_season_ranking_api_get()
except ApiException as e:
    print("Exception when calling ForecastApi->forecastSeasonRankingApiGet: %s\n" % e)
extern crate ForecastApi;

pub fn main() {

    let mut context = ForecastApi::Context::default();
    let result = client.forecastSeasonRankingApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


forecastSeasonRankingGet

forecast/season_ranking


/forecast/season_ranking

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/forecast/season_ranking"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastSeasonRankingGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastSeasonRankingGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastSeasonRankingGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastSeasonRankingGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];

// forecast/season_ranking
[apiInstance forecastSeasonRankingGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastSeasonRankingGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastSeasonRankingGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();

            try {
                // forecast/season_ranking
                apiInstance.forecastSeasonRankingGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastSeasonRankingGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();

try {
    $api_instance->forecastSeasonRankingGet();
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastSeasonRankingGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();

eval {
    $api_instance->forecastSeasonRankingGet();
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastSeasonRankingGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()

try:
    # forecast/season_ranking
    api_instance.forecast_season_ranking_get()
except ApiException as e:
    print("Exception when calling ForecastApi->forecastSeasonRankingGet: %s\n" % e)
extern crate ForecastApi;

pub fn main() {

    let mut context = ForecastApi::Context::default();
    let result = client.forecastSeasonRankingGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


forecastSelectCardApiGet

forecast/select_card_api


/forecast/select_card_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/forecast/select_card_api?slot=1"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();
        Integer slot = 1; // Integer | 1, 2, 3, 4, 5(PG, SG, SF, PF, C)

        try {
            apiInstance.forecastSelectCardApiGet(slot);
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastSelectCardApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();
        Integer slot = 1; // Integer | 1, 2, 3, 4, 5(PG, SG, SF, PF, C)

        try {
            apiInstance.forecastSelectCardApiGet(slot);
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastSelectCardApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];
Integer *slot = 1; // 1, 2, 3, 4, 5(PG, SG, SF, PF, C) (optional) (default to null)

// forecast/select_card_api
[apiInstance forecastSelectCardApiGetWith:slot
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var opts = {
  'slot': 1 // {Integer} 1, 2, 3, 4, 5(PG, SG, SF, PF, C)
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastSelectCardApiGet(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastSelectCardApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();
            var slot = 1;  // Integer | 1, 2, 3, 4, 5(PG, SG, SF, PF, C) (optional)  (default to null)

            try {
                // forecast/select_card_api
                apiInstance.forecastSelectCardApiGet(slot);
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastSelectCardApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();
$slot = 1; // Integer | 1, 2, 3, 4, 5(PG, SG, SF, PF, C)

try {
    $api_instance->forecastSelectCardApiGet($slot);
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastSelectCardApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();
my $slot = 1; # Integer | 1, 2, 3, 4, 5(PG, SG, SF, PF, C)

eval {
    $api_instance->forecastSelectCardApiGet(slot => $slot);
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastSelectCardApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()
slot = 1 # Integer | 1, 2, 3, 4, 5(PG, SG, SF, PF, C) (optional) (default to null)

try:
    # forecast/select_card_api
    api_instance.forecast_select_card_api_get(slot=slot)
except ApiException as e:
    print("Exception when calling ForecastApi->forecastSelectCardApiGet: %s\n" % e)
extern crate ForecastApi;

pub fn main() {
    let slot = 1; // Integer

    let mut context = ForecastApi::Context::default();
    let result = client.forecastSelectCardApiGet(slot, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
slot
Integer
1, 2, 3, 4, 5(PG, SG, SF, PF, C)

Responses


forecastSelectCardGet

forecast/select_card


/forecast/select_card

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/forecast/select_card?slot=1"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();
        Integer slot = 1; // Integer | 1, 2, 3, 4, 5(PG, SG, SF, PF, C)

        try {
            apiInstance.forecastSelectCardGet(slot);
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastSelectCardGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();
        Integer slot = 1; // Integer | 1, 2, 3, 4, 5(PG, SG, SF, PF, C)

        try {
            apiInstance.forecastSelectCardGet(slot);
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastSelectCardGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];
Integer *slot = 1; // 1, 2, 3, 4, 5(PG, SG, SF, PF, C) (optional) (default to null)

// forecast/select_card
[apiInstance forecastSelectCardGetWith:slot
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var opts = {
  'slot': 1 // {Integer} 1, 2, 3, 4, 5(PG, SG, SF, PF, C)
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastSelectCardGet(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastSelectCardGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();
            var slot = 1;  // Integer | 1, 2, 3, 4, 5(PG, SG, SF, PF, C) (optional)  (default to null)

            try {
                // forecast/select_card
                apiInstance.forecastSelectCardGet(slot);
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastSelectCardGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();
$slot = 1; // Integer | 1, 2, 3, 4, 5(PG, SG, SF, PF, C)

try {
    $api_instance->forecastSelectCardGet($slot);
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastSelectCardGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();
my $slot = 1; # Integer | 1, 2, 3, 4, 5(PG, SG, SF, PF, C)

eval {
    $api_instance->forecastSelectCardGet(slot => $slot);
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastSelectCardGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()
slot = 1 # Integer | 1, 2, 3, 4, 5(PG, SG, SF, PF, C) (optional) (default to null)

try:
    # forecast/select_card
    api_instance.forecast_select_card_get(slot=slot)
except ApiException as e:
    print("Exception when calling ForecastApi->forecastSelectCardGet: %s\n" % e)
extern crate ForecastApi;

pub fn main() {
    let slot = 1; // Integer

    let mut context = ForecastApi::Context::default();
    let result = client.forecastSelectCardGet(slot, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
slot
Integer
1, 2, 3, 4, 5(PG, SG, SF, PF, C)

Responses


forecastSpecialBonusApiGet

forecast/special_bonus_api


/forecast/special_bonus_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/forecast/special_bonus_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastSpecialBonusApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastSpecialBonusApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastSpecialBonusApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastSpecialBonusApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];

// forecast/special_bonus_api
[apiInstance forecastSpecialBonusApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastSpecialBonusApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastSpecialBonusApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();

            try {
                // forecast/special_bonus_api
                apiInstance.forecastSpecialBonusApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastSpecialBonusApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();

try {
    $api_instance->forecastSpecialBonusApiGet();
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastSpecialBonusApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();

eval {
    $api_instance->forecastSpecialBonusApiGet();
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastSpecialBonusApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()

try:
    # forecast/special_bonus_api
    api_instance.forecast_special_bonus_api_get()
except ApiException as e:
    print("Exception when calling ForecastApi->forecastSpecialBonusApiGet: %s\n" % e)
extern crate ForecastApi;

pub fn main() {

    let mut context = ForecastApi::Context::default();
    let result = client.forecastSpecialBonusApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


forecastSpecialBonusGet

forecast/special_bonus


/forecast/special_bonus

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/forecast/special_bonus"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ForecastApi;

import java.io.File;
import java.util.*;

public class ForecastApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastSpecialBonusGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastSpecialBonusGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ForecastApi;

public class ForecastApiExample {
    public static void main(String[] args) {
        ForecastApi apiInstance = new ForecastApi();

        try {
            apiInstance.forecastSpecialBonusGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ForecastApi#forecastSpecialBonusGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ForecastApi *apiInstance = [[ForecastApi alloc] init];

// forecast/special_bonus
[apiInstance forecastSpecialBonusGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ForecastApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.forecastSpecialBonusGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class forecastSpecialBonusGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ForecastApi();

            try {
                // forecast/special_bonus
                apiInstance.forecastSpecialBonusGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ForecastApi.forecastSpecialBonusGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ForecastApi();

try {
    $api_instance->forecastSpecialBonusGet();
} catch (Exception $e) {
    echo 'Exception when calling ForecastApi->forecastSpecialBonusGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ForecastApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ForecastApi->new();

eval {
    $api_instance->forecastSpecialBonusGet();
};
if ($@) {
    warn "Exception when calling ForecastApi->forecastSpecialBonusGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ForecastApi()

try:
    # forecast/special_bonus
    api_instance.forecast_special_bonus_get()
except ApiException as e:
    print("Exception when calling ForecastApi->forecastSpecialBonusGet: %s\n" % e)
extern crate ForecastApi;

pub fn main() {

    let mut context = ForecastApi::Context::default();
    let result = client.forecastSpecialBonusGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


Friend

friendApiGet

friend_api


/friend_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/friend_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.FriendApi;

import java.io.File;
import java.util.*;

public class FriendApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        FriendApi apiInstance = new FriendApi();

        try {
            apiInstance.friendApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling FriendApi#friendApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.FriendApi;

public class FriendApiExample {
    public static void main(String[] args) {
        FriendApi apiInstance = new FriendApi();

        try {
            apiInstance.friendApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling FriendApi#friendApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
FriendApi *apiInstance = [[FriendApi alloc] init];

// friend_api
[apiInstance friendApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.FriendApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.friendApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class friendApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new FriendApi();

            try {
                // friend_api
                apiInstance.friendApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling FriendApi.friendApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FriendApi();

try {
    $api_instance->friendApiGet();
} catch (Exception $e) {
    echo 'Exception when calling FriendApi->friendApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::FriendApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FriendApi->new();

eval {
    $api_instance->friendApiGet();
};
if ($@) {
    warn "Exception when calling FriendApi->friendApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.FriendApi()

try:
    # friend_api
    api_instance.friend_api_get()
except ApiException as e:
    print("Exception when calling FriendApi->friendApiGet: %s\n" % e)
extern crate FriendApi;

pub fn main() {

    let mut context = FriendApi::Context::default();
    let result = client.friendApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


friendGet

friend


/friend

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/friend"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.FriendApi;

import java.io.File;
import java.util.*;

public class FriendApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        FriendApi apiInstance = new FriendApi();

        try {
            apiInstance.friendGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling FriendApi#friendGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.FriendApi;

public class FriendApiExample {
    public static void main(String[] args) {
        FriendApi apiInstance = new FriendApi();

        try {
            apiInstance.friendGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling FriendApi#friendGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
FriendApi *apiInstance = [[FriendApi alloc] init];

// friend
[apiInstance friendGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.FriendApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.friendGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class friendGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new FriendApi();

            try {
                // friend
                apiInstance.friendGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling FriendApi.friendGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FriendApi();

try {
    $api_instance->friendGet();
} catch (Exception $e) {
    echo 'Exception when calling FriendApi->friendGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::FriendApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FriendApi->new();

eval {
    $api_instance->friendGet();
};
if ($@) {
    warn "Exception when calling FriendApi->friendGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.FriendApi()

try:
    # friend
    api_instance.friend_get()
except ApiException as e:
    print("Exception when calling FriendApi->friendGet: %s\n" % e)
extern crate FriendApi;

pub fn main() {

    let mut context = FriendApi::Context::default();
    let result = client.friendGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


Gacha

gachaContentsApiGachaIdGet

gacha/contents_api/:cacha_id


/gacha/contents_api/{gacha_id}

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/gacha/contents_api/{gacha_id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GachaApi;

import java.io.File;
import java.util.*;

public class GachaApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        GachaApi apiInstance = new GachaApi();
        String gachaId = gachaId_example; // String | 

        try {
            apiInstance.gachaContentsApiGachaIdGet(gachaId);
        } catch (ApiException e) {
            System.err.println("Exception when calling GachaApi#gachaContentsApiGachaIdGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.GachaApi;

public class GachaApiExample {
    public static void main(String[] args) {
        GachaApi apiInstance = new GachaApi();
        String gachaId = gachaId_example; // String | 

        try {
            apiInstance.gachaContentsApiGachaIdGet(gachaId);
        } catch (ApiException e) {
            System.err.println("Exception when calling GachaApi#gachaContentsApiGachaIdGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
GachaApi *apiInstance = [[GachaApi alloc] init];
String *gachaId = gachaId_example; //  (default to null)

// gacha/contents_api/:cacha_id
[apiInstance gachaContentsApiGachaIdGetWith:gachaId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.GachaApi()
var gachaId = gachaId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.gachaContentsApiGachaIdGet(gachaId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class gachaContentsApiGachaIdGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new GachaApi();
            var gachaId = gachaId_example;  // String |  (default to null)

            try {
                // gacha/contents_api/:cacha_id
                apiInstance.gachaContentsApiGachaIdGet(gachaId);
            } catch (Exception e) {
                Debug.Print("Exception when calling GachaApi.gachaContentsApiGachaIdGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GachaApi();
$gachaId = gachaId_example; // String | 

try {
    $api_instance->gachaContentsApiGachaIdGet($gachaId);
} catch (Exception $e) {
    echo 'Exception when calling GachaApi->gachaContentsApiGachaIdGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GachaApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GachaApi->new();
my $gachaId = gachaId_example; # String | 

eval {
    $api_instance->gachaContentsApiGachaIdGet(gachaId => $gachaId);
};
if ($@) {
    warn "Exception when calling GachaApi->gachaContentsApiGachaIdGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.GachaApi()
gachaId = gachaId_example # String |  (default to null)

try:
    # gacha/contents_api/:cacha_id
    api_instance.gacha_contents_api_gacha_id_get(gachaId)
except ApiException as e:
    print("Exception when calling GachaApi->gachaContentsApiGachaIdGet: %s\n" % e)
extern crate GachaApi;

pub fn main() {
    let gachaId = gachaId_example; // String

    let mut context = GachaApi::Context::default();
    let result = client.gachaContentsApiGachaIdGet(gachaId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
gacha_id*
String
Required

Responses


gachaContentsGachaIdGet

gacha/contents/:cacha_id


/gacha/contents/{gacha_id}

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/gacha/contents/{gacha_id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GachaApi;

import java.io.File;
import java.util.*;

public class GachaApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        GachaApi apiInstance = new GachaApi();
        String gachaId = gachaId_example; // String | 

        try {
            apiInstance.gachaContentsGachaIdGet(gachaId);
        } catch (ApiException e) {
            System.err.println("Exception when calling GachaApi#gachaContentsGachaIdGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.GachaApi;

public class GachaApiExample {
    public static void main(String[] args) {
        GachaApi apiInstance = new GachaApi();
        String gachaId = gachaId_example; // String | 

        try {
            apiInstance.gachaContentsGachaIdGet(gachaId);
        } catch (ApiException e) {
            System.err.println("Exception when calling GachaApi#gachaContentsGachaIdGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
GachaApi *apiInstance = [[GachaApi alloc] init];
String *gachaId = gachaId_example; //  (default to null)

// gacha/contents/:cacha_id
[apiInstance gachaContentsGachaIdGetWith:gachaId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.GachaApi()
var gachaId = gachaId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.gachaContentsGachaIdGet(gachaId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class gachaContentsGachaIdGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new GachaApi();
            var gachaId = gachaId_example;  // String |  (default to null)

            try {
                // gacha/contents/:cacha_id
                apiInstance.gachaContentsGachaIdGet(gachaId);
            } catch (Exception e) {
                Debug.Print("Exception when calling GachaApi.gachaContentsGachaIdGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GachaApi();
$gachaId = gachaId_example; // String | 

try {
    $api_instance->gachaContentsGachaIdGet($gachaId);
} catch (Exception $e) {
    echo 'Exception when calling GachaApi->gachaContentsGachaIdGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GachaApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GachaApi->new();
my $gachaId = gachaId_example; # String | 

eval {
    $api_instance->gachaContentsGachaIdGet(gachaId => $gachaId);
};
if ($@) {
    warn "Exception when calling GachaApi->gachaContentsGachaIdGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.GachaApi()
gachaId = gachaId_example # String |  (default to null)

try:
    # gacha/contents/:cacha_id
    api_instance.gacha_contents_gacha_id_get(gachaId)
except ApiException as e:
    print("Exception when calling GachaApi->gachaContentsGachaIdGet: %s\n" % e)
extern crate GachaApi;

pub fn main() {
    let gachaId = gachaId_example; // String

    let mut context = GachaApi::Context::default();
    let result = client.gachaContentsGachaIdGet(gachaId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
gacha_id*
String
Required

Responses


gachaDetailApiGachaIdGet

gacha/detail_api/:gacha_id


/gacha/detail_api/{gacha_id}

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/gacha/detail_api/{gacha_id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GachaApi;

import java.io.File;
import java.util.*;

public class GachaApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        GachaApi apiInstance = new GachaApi();
        String gachaId = gachaId_example; // String | 

        try {
            Object result = apiInstance.gachaDetailApiGachaIdGet(gachaId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GachaApi#gachaDetailApiGachaIdGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.GachaApi;

public class GachaApiExample {
    public static void main(String[] args) {
        GachaApi apiInstance = new GachaApi();
        String gachaId = gachaId_example; // String | 

        try {
            Object result = apiInstance.gachaDetailApiGachaIdGet(gachaId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GachaApi#gachaDetailApiGachaIdGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
GachaApi *apiInstance = [[GachaApi alloc] init];
String *gachaId = gachaId_example; //  (default to null)

// gacha/detail_api/:gacha_id
[apiInstance gachaDetailApiGachaIdGetWith:gachaId
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.GachaApi()
var gachaId = gachaId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.gachaDetailApiGachaIdGet(gachaId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class gachaDetailApiGachaIdGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new GachaApi();
            var gachaId = gachaId_example;  // String |  (default to null)

            try {
                // gacha/detail_api/:gacha_id
                Object result = apiInstance.gachaDetailApiGachaIdGet(gachaId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GachaApi.gachaDetailApiGachaIdGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GachaApi();
$gachaId = gachaId_example; // String | 

try {
    $result = $api_instance->gachaDetailApiGachaIdGet($gachaId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GachaApi->gachaDetailApiGachaIdGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GachaApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GachaApi->new();
my $gachaId = gachaId_example; # String | 

eval {
    my $result = $api_instance->gachaDetailApiGachaIdGet(gachaId => $gachaId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GachaApi->gachaDetailApiGachaIdGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.GachaApi()
gachaId = gachaId_example # String |  (default to null)

try:
    # gacha/detail_api/:gacha_id
    api_response = api_instance.gacha_detail_api_gacha_id_get(gachaId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GachaApi->gachaDetailApiGachaIdGet: %s\n" % e)
extern crate GachaApi;

pub fn main() {
    let gachaId = gachaId_example; // String

    let mut context = GachaApi::Context::default();
    let result = client.gachaDetailApiGachaIdGet(gachaId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
gacha_id*
String
Required

Responses

Name Type Format Description
Date String
ContentMinusType String
TransferMinusEncoding String
Connection String
Server String
XMinusPoweredMinusBy BigDecimal
Expires String
CacheMinusControl String
Pragma String

gachaDetailGachaIdGet

gacha/detail/:gacha_id


/gacha/detail/{gacha_id}

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: text/plain" \
 "http://localhost/gacha/detail/{gacha_id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GachaApi;

import java.io.File;
import java.util.*;

public class GachaApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        GachaApi apiInstance = new GachaApi();
        String gachaId = gachaId_example; // String | 

        try {
            'String' result = apiInstance.gachaDetailGachaIdGet(gachaId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GachaApi#gachaDetailGachaIdGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.GachaApi;

public class GachaApiExample {
    public static void main(String[] args) {
        GachaApi apiInstance = new GachaApi();
        String gachaId = gachaId_example; // String | 

        try {
            'String' result = apiInstance.gachaDetailGachaIdGet(gachaId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GachaApi#gachaDetailGachaIdGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
GachaApi *apiInstance = [[GachaApi alloc] init];
String *gachaId = gachaId_example; //  (default to null)

// gacha/detail/:gacha_id
[apiInstance gachaDetailGachaIdGetWith:gachaId
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.GachaApi()
var gachaId = gachaId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.gachaDetailGachaIdGet(gachaId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class gachaDetailGachaIdGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new GachaApi();
            var gachaId = gachaId_example;  // String |  (default to null)

            try {
                // gacha/detail/:gacha_id
                'String' result = apiInstance.gachaDetailGachaIdGet(gachaId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GachaApi.gachaDetailGachaIdGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GachaApi();
$gachaId = gachaId_example; // String | 

try {
    $result = $api_instance->gachaDetailGachaIdGet($gachaId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GachaApi->gachaDetailGachaIdGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GachaApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GachaApi->new();
my $gachaId = gachaId_example; # String | 

eval {
    my $result = $api_instance->gachaDetailGachaIdGet(gachaId => $gachaId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GachaApi->gachaDetailGachaIdGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.GachaApi()
gachaId = gachaId_example # String |  (default to null)

try:
    # gacha/detail/:gacha_id
    api_response = api_instance.gacha_detail_gacha_id_get(gachaId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GachaApi->gachaDetailGachaIdGet: %s\n" % e)
extern crate GachaApi;

pub fn main() {
    let gachaId = gachaId_example; // String

    let mut context = GachaApi::Context::default();
    let result = client.gachaDetailGachaIdGet(gachaId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
gacha_id*
String
Required

Responses

\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
\n
\n \n
\n \n \n \n \n \n \n \n \n \n \n ニックネーム未設定\n --\n \n \n 0\n 55\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
\n \n \"ページトップ\"/\n \n
\n
\n \n
\n \n \n \n
\n
\n
\n
\n

カード詳細

\n
\n 「バレンタインキャンペーンカードパック」は、「B.クリスタル」を消費してカードを引くカードパックです。\n
\n ※対象期間は2/1(火)~2/15(火)PM3:59まで。\n
\n
\n 「バレンタインキャンペーンカードパック」で「10枚ひく」を行うと、下記、確定分カードラインナップの\n ★4いずれかが必ず2枚当たります!\n
\n
\n
\n
\n

レア度ごとの登場確率

\n ※2/1(火)時点\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
★★★★★\n \n  2.5%
★★★★\n \n  5%
★★★\n ☆☆\n  35%
★★\n ☆☆☆\n  57.5%
\n
\n

【確定分】レア度ごとの登場確率

\n ※2/1(火)時点\n \n \n \n \n \n
★★★★\n \n  100%
\n
\n
\n

確定分カードラインナップ

\n ※2/1(火)時点\n
\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
 
\n ☆☆☆☆(スーパーレアカード)\n
北海道_17番 山口 颯斗(バレンタインキャンペーン)(★4)
秋田_16番 伊藤 駿(バレンタインキャンペーン)(★4)
茨城_8番 多嶋 朝飛(バレンタインキャンペーン)(★4)
宇都宮_40番 ジョシュ・スコット(バレンタインキャンペーン)(★4)
群馬_14番 菅原 暉(バレンタインキャンペーン)(★4)
千葉_13番 大倉 颯太(バレンタインキャンペーン)(★4)
A東京_75番 小酒部 泰暉(バレンタインキャンペーン)(★4)
SR渋谷_27番 石井 講祐(バレンタインキャンペーン)(★4)
川崎_20番 綱井 勇介(バレンタインキャンペーン)(★4)
横浜_4番 ジェイコブス 晶(バレンタインキャンペーン)(★4)
新潟_6番 コービー・パラス(バレンタインキャンペーン)(★4)
富山_24番 ドワイト・ラモス(バレンタインキャンペーン)(★4)
信州_19番 大崎 裕太(バレンタインキャンペーン)(★4)
三遠_14番 松脇 圭志(バレンタインキャンペーン)(★4)
三河_19番 西田 優大(バレンタインキャンペーン)(★4)
名古屋D_2番 齋藤 拓実(バレンタインキャンペーン)(★4)
滋賀_16番 野本 大智(バレンタインキャンペーン)(★4)
京都_21番 満田 丈太郎(バレンタインキャンペーン)(★4)
大阪_11番 ザック・モーア(バレンタインキャンペーン)(★4)
島根_3番 安藤 誓哉(バレンタインキャンペーン)(★4)
広島_3番 辻 直人(バレンタインキャンペーン)(★4)
琉球_88番 牧 隼利(バレンタインキャンペーン)(★4)
青森_11番 駒沢 颯(バレンタインキャンペーン)(★4)
仙台_75番 神里 和(バレンタインキャンペーン)(★4)
山形_28番 川邉 亮平(バレンタインキャンペーン)(★4)
福島_11番 山内 翼(バレンタインキャンペーン)(★4)
越谷_21番 鎌田 真(バレンタインキャンペーン)(★4)
東京Z_14番 久岡 幸太郎(バレンタインキャンペーン)(★4)
FE名古屋_11番 石川 海斗(バレンタインキャンペーン)(★4)
西宮_10番 渡邊 翔太(バレンタインキャンペーン)(★4)
奈良_3番 藤髙 宗一郎(バレンタインキャンペーン)(★4)
香川_93番 上良 潤起(バレンタインキャンペーン)(★4)
愛媛_0番 宇都宮 陸(バレンタインキャンペーン)(★4)
福岡_11番 白戸 大聖(バレンタインキャンペーン)(★4)
佐賀_25番 角田 太輝(バレンタインキャンペーン)(★4)
熊本_24番 佐々木 隆成(バレンタインキャンペーン)(★4)
 
\n
\n

確定分以外のカードラインナップ

\n ※2/1(火)時点\n
\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
 
\n ☆☆☆☆☆(シークレットスーパーレアカード)\n
宇都宮_3番 ブランドン・ジャワト(オールスターvol.2)(★5)
川崎_11番 増田 啓介(オールスターvol.2)(★5)
富山_24番 ドワイト・ラモス(オールスターvol.2)(★5)
三遠_0番 サーディ・ラベナ(オールスターvol.2)(★5)
広島_0番 寺嶋 良(オールスターvol.2)(★5)
琉球_4番 コー・フリッピン(オールスターvol.2)(★5)
宇都宮_11番 荒谷 裕秀(ルーキー)(★5)
群馬_14番 菅原 暉(ルーキー)(★5)
川崎_3番 米須 玲音(ルーキー)(★5)
横浜_5番 河村 勇輝(ルーキー)(★5)
新潟_34番 遠藤 善(ルーキー)(★5)
滋賀_16番 野本 大智(ルーキー)(★5)
秋田_5番 田口 成浩(雄叫び)(★5)
宇都宮_9番 遠藤 祐亮(雄叫び)(★5)
横浜_32番 エドワード・モリス(雄叫び)(★5)
新潟_15番 チリジ・ネパウェ(雄叫び)(★5)
大阪_25番 ディージェイ・ニュービル(雄叫び)(★5)
広島_10番 チャールズ・ジャクソン(雄叫び)(★5)
琉球_30番 今村 佳太(雄叫び)(★5)
宇都宮_6番 比江島 慎(オールスター)(★5)
宇都宮_40番 ジョシュ・スコット(オールスター)(★5)
千葉_2番 富樫 勇樹(オールスター)(★5)
A東京_11番 セバスチャン・サイズ(オールスター)(★5)
A東京_22番 ライアン・ロシター(オールスター)(★5)
川崎_7番 篠山 竜青(オールスター)(★5)
三河_32番 シェーファー アヴィ幸樹(オールスター)(★5)
島根_14番 金丸 晃輔(オールスター)(★5)
琉球_14番 岸本 隆一(オールスター)(★5)
琉球_45番 ジャック・クーリー(オールスター)(★5)
北海道_0番 橋本 竜馬(キャプテン)(★5)
秋田_17番 中山 拓哉(キャプテン)(★5)
茨城_25番 平尾 充庸(キャプテン)(★5)
宇都宮_0番 田臥 勇太(キャプテン)(★5)
群馬_13番 笠井 康平(キャプテン)(★5)
千葉_2番 富樫 勇樹(キャプテン)(★5)
横浜_46番 生原 秀将(キャプテン)(★5)
富山_0番 小野 龍猛(キャプテン)(★5)
信州_50番 ウェイン・マーシャル(キャプテン)(★5)
名古屋D_32番 狩野 祐介(キャプテン)(★5)
滋賀_14番 柏倉 哲平(キャプテン)(★5)
大阪_20番 合田 怜(キャプテン)(★5)
島根_3番 安藤 誓哉(キャプテン)(★5)
広島_8番 グレゴリー・エチェニケ(キャプテン)(★5)
北海道_25番 葛原 大智(背番号)(★5)
宇都宮_7番 テーブス 海(背番号)(★5)
A東京_24番 田中 大貴(背番号)(★5)
新潟_0番 岡本 飛竜(背番号)(★5)
三遠_21番 田渡 凌(背番号)(★5)
大阪_1番 青木 龍史(背番号)(★5)
島根_2番 ぺリン・ビュフォード(背番号)(★5)
B.LEAGUE_0番 福澤 晃平vs田臥 勇太(1on1)(★5)
B.LEAGUE_0番 藤井 祐眞vs宇都 直輝(1on1)(★5)
B.LEAGUE_0番 森山 修斗vsサーディ・ラベナ(1on1)(★5)
B.LEAGUE_0番 ぺリン・ビュフォードvs山口 颯斗(1on1)(★5)
B.LEAGUE_0番 富樫 勇樹vs田中 大貴(1on1)(★5)
B.LEAGUE_0番 関野 剛平vs中山 拓哉(1on1)(★5)
B.LEAGUE_0番 ロスコ・アレンvsアレン・ダーラム(1on1)(★5)
B.LEAGUE_0番 岸本 隆一vs篠山 竜青(1on1)(★5)
千葉_8番 大宮 宏正(スマイル)(★5)
A東京_11番 セバスチャン・サイズ(スマイル)(★5)
SR渋谷_12番 西野 曜(スマイル)(★5)
川崎_22番 ニック・ファジーカス(スマイル)(★5)
名古屋D_2番 齋藤 拓実(スマイル)(★5)
広島_2番 朝山 正悟(スマイル)(★5)
琉球_45番 ジャック・クーリー(スマイル)(★5)
宇都宮_6番 比江島 慎(DRIVE YOU CRAZY)(★5)
群馬_4番 トレイ・ジョーンズ(DRIVE YOU CRAZY)(★5)
A東京_11番 セバスチャン・サイズ(DRIVE YOU CRAZY)(★5)
SR渋谷_9番 ベンドラメ 礼生(DRIVE YOU CRAZY)(★5)
川崎_0番 藤井 祐眞(DRIVE YOU CRAZY)(★5)
三河_54番 ダバンテ・ガードナー(DRIVE YOU CRAZY)(★5)
京都_25番 鈴木 達也(DRIVE YOU CRAZY)(★5)
北海道_0番 橋本 竜馬(2021-22シーズン)(★5)
秋田_51番 古川 孝敏(2021-22シーズン)(★5)
茨城_25番 平尾 充庸(2021-22シーズン)(★5)
宇都宮_7番 テーブス 海(2021-22シーズン)(★5)
宇都宮_9番 遠藤 祐亮(2021-22シーズン)(★5)
群馬_40番 ジャスティン・キーナン(2021-22シーズン)(★5)
千葉_2番 富樫 勇樹(2021-22シーズン)(★5)
A東京_24番 田中 大貴(2021-22シーズン)(★5)
SR渋谷_34番 ライアン・ケリー(2021-22シーズン)(★5)
川崎_7番 篠山 竜青(2021-22シーズン)(★5)
川崎_13番 前田 悟(2021-22シーズン)(★5)
横浜_46番 生原 秀将(2021-22シーズン)(★5)
新潟_32番 池田 雄一(2021-22シーズン)(★5)
富山_11番 宇都 直輝(2021-22シーズン)(★5)
信州_15番 前田 怜緒(2021-22シーズン)(★5)
信州_55番 アンソニー・マクヘンリー(2021-22シーズン)(★5)
三遠_8番 太田 敦也(2021-22シーズン)(★5)
三河_32番 シェーファー アヴィ幸樹(2021-22シーズン)(★5)
名古屋D_2番 齋藤 拓実(2021-22シーズン)(★5)
滋賀_15番 キーファー・ラベナ(2021-22シーズン)(★5)
滋賀_33番 林 翔太郎(2021-22シーズン)(★5)
京都_21番 満田 丈太郎(2021-22シーズン)(★5)
大阪_25番 ディージェイ・ニュービル(2021-22シーズン)(★5)
大阪_33番 アイラ・ブラウン(2021-22シーズン)(★5)
島根_5番 山下 泰弘(2021-22シーズン)(★5)
島根_14番 金丸 晃輔(2021-22シーズン)(★5)
広島_0番 寺嶋 良(2021-22シーズン)(★5)
広島_5番 アイザイア・マーフィー(2021-22シーズン)(★5)
琉球_3番 並里 成(2021-22シーズン)(★5)
琉球_24番 田代 直希(2021-22シーズン)(★5)
 
\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
 
\n ☆☆☆☆(スーパーレアカード)\n
北海道_17番 山口 颯斗(バレンタインキャンペーン)(★4)
秋田_16番 伊藤 駿(バレンタインキャンペーン)(★4)
茨城_8番 多嶋 朝飛(バレンタインキャンペーン)(★4)
宇都宮_40番 ジョシュ・スコット(バレンタインキャンペーン)(★4)
群馬_14番 菅原 暉(バレンタインキャンペーン)(★4)
千葉_13番 大倉 颯太(バレンタインキャンペーン)(★4)
A東京_75番 小酒部 泰暉(バレンタインキャンペーン)(★4)
SR渋谷_27番 石井 講祐(バレンタインキャンペーン)(★4)
川崎_20番 綱井 勇介(バレンタインキャンペーン)(★4)
横浜_4番 ジェイコブス 晶(バレンタインキャンペーン)(★4)
新潟_6番 コービー・パラス(バレンタインキャンペーン)(★4)
富山_24番 ドワイト・ラモス(バレンタインキャンペーン)(★4)
信州_19番 大崎 裕太(バレンタインキャンペーン)(★4)
三遠_14番 松脇 圭志(バレンタインキャンペーン)(★4)
三河_19番 西田 優大(バレンタインキャンペーン)(★4)
名古屋D_2番 齋藤 拓実(バレンタインキャンペーン)(★4)
滋賀_16番 野本 大智(バレンタインキャンペーン)(★4)
京都_21番 満田 丈太郎(バレンタインキャンペーン)(★4)
大阪_11番 ザック・モーア(バレンタインキャンペーン)(★4)
島根_3番 安藤 誓哉(バレンタインキャンペーン)(★4)
広島_3番 辻 直人(バレンタインキャンペーン)(★4)
琉球_88番 牧 隼利(バレンタインキャンペーン)(★4)
青森_11番 駒沢 颯(バレンタインキャンペーン)(★4)
仙台_75番 神里 和(バレンタインキャンペーン)(★4)
山形_28番 川邉 亮平(バレンタインキャンペーン)(★4)
福島_11番 山内 翼(バレンタインキャンペーン)(★4)
越谷_21番 鎌田 真(バレンタインキャンペーン)(★4)
東京Z_14番 久岡 幸太郎(バレンタインキャンペーン)(★4)
FE名古屋_11番 石川 海斗(バレンタインキャンペーン)(★4)
西宮_10番 渡邊 翔太(バレンタインキャンペーン)(★4)
奈良_3番 藤髙 宗一郎(バレンタインキャンペーン)(★4)
香川_93番 上良 潤起(バレンタインキャンペーン)(★4)
愛媛_0番 宇都宮 陸(バレンタインキャンペーン)(★4)
福岡_11番 白戸 大聖(バレンタインキャンペーン)(★4)
佐賀_25番 角田 太輝(バレンタインキャンペーン)(★4)
熊本_24番 佐々木 隆成(バレンタインキャンペーン)(★4)
秋田_1番 王 偉嘉(オールスターvol.2)(★4)
茨城_22番 ハビエル・ゴメス・デ・リアニョ(オールスターvol.2)(★4)
宇都宮_7番 テーブス 海(オールスターvol.2)(★4)
千葉_14番 佐藤 卓磨(オールスターvol.2)(★4)
A東京_75番 小酒部 泰暉(オールスターvol.2)(★4)
川崎_13番 前田 悟(オールスターvol.2)(★4)
新潟_6番 コービー・パラス(オールスターvol.2)(★4)
新潟_21番 納見 悠仁(オールスターvol.2)(★4)
信州_5番 ヤン ジェミン(オールスターvol.2)(★4)
信州_13番 マシュー・アキノ(オールスターvol.2)(★4)
三河_18番 角野 亮伍(オールスターvol.2)(★4)
名古屋D_1番 レイ・パークスジュニア(オールスターvol.2)(★4)
名古屋D_2番 齋藤 拓実(オールスターvol.2)(★4)
滋賀_15番 キーファー・ラベナ(オールスターvol.2)(★4)
大阪_3番 エリエット・ドンリー(オールスターvol.2)(★4)
琉球_30番 今村 佳太(オールスターvol.2)(★4)
青森_19番 カマーク・カリノ(オールスターvol.2)(★4)
東京Z_1番 ホアン・ゴメス デ リアノ(オールスターvol.2)(★4)
西宮_23番 劉 瑾(オールスターvol.2)(★4)
福岡_12番 林郅為(オールスターvol.2)(★4)
北海道_17番 山口 颯斗(ルーキー)(★4)
群馬_8番 八村 阿蓮(ルーキー)(★4)
群馬_10番 杉本 天昇(ルーキー)(★4)
A東京_8番 吉井 裕鷹(ルーキー)(★4)
SR渋谷_12番 西野 曜(ルーキー)(★4)
新潟_14番 木村 圭吾(ルーキー)(★4)
富山_2番 飴谷 由毅(ルーキー)(★4)
富山_10番 上澤 俊喜(ルーキー)(★4)
三遠_28番 津屋 一球(ルーキー)(★4)
滋賀_99番 川真田 紘也(ルーキー)(★4)
大阪_11番 ザック・モーア(ルーキー)(★4)
広島_14番 柳川 幹也(ルーキー)(★4)
北海道_1番 ナナー ダニエル弾(雄叫び)(★4)
茨城_25番 平尾 充庸(雄叫び)(★4)
群馬_3番 マイケル・パーカー(雄叫び)(★4)
千葉_2番 富樫 勇樹(雄叫び)(★4)
A東京_24番 田中 大貴(雄叫び)(★4)
SR渋谷_44番 盛實 海翔(雄叫び)(★4)
川崎_13番 前田 悟(雄叫び)(★4)
富山_5番 ブライス・ジョンソン(雄叫び)(★4)
信州_50番 ウェイン・マーシャル(雄叫び)(★4)
三遠_20番 エリアス・ハリス(雄叫び)(★4)
三河_19番 西田 優大(雄叫び)(★4)
名古屋D_1番 レイ・パークスジュニア(雄叫び)(★4)
滋賀_14番 柏倉 哲平(雄叫び)(★4)
京都_32番 ジャスティン・ハーパー(雄叫び)(★4)
島根_28番 ウィリアムス ニカ(雄叫び)(★4)
北海道_0番 橋本 竜馬(オールスター)(★4)
群馬_4番 トレイ・ジョーンズ(オールスター)(★4)
千葉_31番 原 修太(オールスター)(★4)
A東京_24番 田中 大貴(オールスター)(★4)
SR渋谷_9番 ベンドラメ 礼生(オールスター)(★4)
川崎_0番 藤井 祐眞(オールスター)(★4)
富山_11番 宇都 直輝(オールスター)(★4)
富山_32番 ジュリアン・マブンガ(オールスター)(★4)
信州_55番 アンソニー・マクヘンリー(オールスター)(★4)
信州_77番 岡田 侑大(オールスター)(★4)
三遠_32番 山内 盛久(オールスター)(★4)
三河_19番 西田 優大(オールスター)(★4)
名古屋D_8番 張本 天傑(オールスター)(★4)
島根_3番 安藤 誓哉(オールスター)(★4)
広島_3番 辻 直人(オールスター)(★4)
広島_24番 ニック・メイヨ(オールスター)(★4)
琉球_3番 並里 成(オールスター)(★4)
秋田_51番 古川 孝敏(キャプテン)(★4)
群馬_3番 マイケル・パーカー(キャプテン)(★4)
A東京_24番 田中 大貴(キャプテン)(★4)
SR渋谷_9番 ベンドラメ 礼生(キャプテン)(★4)
川崎_0番 藤井 祐眞(キャプテン)(★4)
新潟_0番 岡本 飛竜(キャプテン)(★4)
信州_55番 アンソニー・マクヘンリー(キャプテン)(★4)
三遠_21番 田渡 凌(キャプテン)(★4)
三河_15番 根來 新之助(キャプテン)(★4)
京都_21番 満田 丈太郎(キャプテン)(★4)
琉球_24番 田代 直希(キャプテン)(★4)
青森_8番 下山 大地(キャプテン)(★4)
仙台_8番 月野 雅人(キャプテン)(★4)
仙台_24番 ジャスティン・バーレル(キャプテン)(★4)
山形_37番 河野 誠司(キャプテン)(★4)
福島_21番 菅野 翔太(キャプテン)(★4)
越谷_8番 長谷川 智也(キャプテン)(★4)
東京Z_14番 久岡 幸太郎(キャプテン)(★4)
FE名古屋_1番 宮崎 恭行(キャプテン)(★4)
西宮_1番 今野 翔太(キャプテン)(★4)
西宮_9番 谷 直樹(キャプテン)(★4)
奈良_3番 藤髙 宗一郎(キャプテン)(★4)
香川_34番 兒玉 貴通(キャプテン)(★4)
愛媛_13番 俊野 佳彦(キャプテン)(★4)
福岡_10番 本多 純平(キャプテン)(★4)
佐賀_24番 石谷 聡(キャプテン)(★4)
熊本_25番 ジョーダン・ハミルトン(キャプテン)(★4)
熊本_30番 古野 拓巳(キャプテン)(★4)
秋田_1番 王 偉嘉(背番号)(★4)
茨城_8番 多嶋 朝飛(背番号)(★4)
群馬_15番 アキ・チェンバース(背番号)(★4)
千葉_2番 富樫 勇樹(背番号)(★4)
SR渋谷_14番 ジェームズ・マイケル・マカドゥ(背番号)(★4)
川崎_27番 熊谷 尚也(背番号)(★4)
横浜_46番 生原 秀将(背番号)(★4)
富山_32番 ジュリアン・マブンガ(背番号)(★4)
信州_55番 アンソニー・マクヘンリー(背番号)(★4)
三河_32番 シェーファー アヴィ幸樹(背番号)(★4)
名古屋D_3番 伊藤 達哉(背番号)(★4)
滋賀_54番 ショーン・オマラ(背番号)(★4)
京都_25番 鈴木 達也(背番号)(★4)
広島_2番 朝山 正悟(背番号)(★4)
琉球_14番 岸本 隆一(背番号)(★4)
B.LEAGUE_0番 ダニエル・ミラーvsジョシュ・ダンカン(1on1)(★4)
B.LEAGUE_0番 菅原 暉vsカイル・コリンズワース(1on1)(★4)
B.LEAGUE_0番 菊地 祥平vs内海 慎吾(1on1)(★4)
B.LEAGUE_0番 大崎 裕太vs森井 健太(1on1)(★4)
B.LEAGUE_0番 張本 天傑vsニック・メイヨ(1on1)(★4)
B.LEAGUE_0番 カイル・ハントvs前田 怜緒(1on1)(★4)
B.LEAGUE_0番 青木 保憲vsベンドラメ 礼生(1on1)(★4)
B.LEAGUE_0番 長谷川 暢vs多嶋 朝飛(1on1)(★4)
B.LEAGUE_0番 テーブス 海vs五十嵐 圭(1on1)(★4)
B.LEAGUE_0番 エドワード・モリスvsリード・トラビス(1on1)(★4)
B.LEAGUE_0番 水戸 健史vs中村 浩陸(1on1)(★4)
B.LEAGUE_0番 山内 盛久vs佐藤 公威(1on1)(★4)
B.LEAGUE_0番 西田 優大vs須田 侑太郎(1on1)(★4)
B.LEAGUE_0番 ジャスティン・ハーパーvs川真田 紘也(1on1)(★4)
北海道_15番 玉木 祥護(スマイル)(★4)
秋田_45番 コルトン・アイバーソン(スマイル)(★4)
茨城_0番 遥 天翼(スマイル)(★4)
宇都宮_10番 竹内 公輔(スマイル)(★4)
群馬_3番 マイケル・パーカー(スマイル)(★4)
横浜_11番 阿部 龍星(スマイル)(★4)
新潟_3番 大矢 孝太朗(スマイル)(★4)
富山_33番 晴山 ケビン(スマイル)(★4)
信州_50番 ウェイン・マーシャル(スマイル)(★4)
三遠_14番 松脇 圭志(スマイル)(★4)
三河_18番 角野 亮伍(スマイル)(★4)
滋賀_15番 キーファー・ラベナ(スマイル)(★4)
京都_50番 デイヴィッド・サイモン(スマイル)(★4)
大阪_33番 アイラ・ブラウン(スマイル)(★4)
島根_3番 安藤 誓哉(スマイル)(★4)
北海道_4番 寺園 脩斗(DRIVE YOU CRAZY)(★4)
秋田_7番 ジョーダン・グリン(DRIVE YOU CRAZY)(★4)
茨城_8番 多嶋 朝飛(DRIVE YOU CRAZY)(★4)
千葉_15番 藤永 佳昭(DRIVE YOU CRAZY)(★4)
横浜_9番 森川 正明(DRIVE YOU CRAZY)(★4)
新潟_6番 コービー・パラス(DRIVE YOU CRAZY)(★4)
富山_32番 ジュリアン・マブンガ(DRIVE YOU CRAZY)(★4)
信州_77番 岡田 侑大(DRIVE YOU CRAZY)(★4)
三遠_21番 田渡 凌(DRIVE YOU CRAZY)(★4)
名古屋D_2番 齋藤 拓実(DRIVE YOU CRAZY)(★4)
滋賀_1番 オヴィ・ソコ(DRIVE YOU CRAZY)(★4)
大阪_2番 ケドリック・ストックマン・ジュニア(DRIVE YOU CRAZY)(★4)
島根_14番 金丸 晃輔(DRIVE YOU CRAZY)(★4)
広島_2番 朝山 正悟(DRIVE YOU CRAZY)(★4)
琉球_88番 牧 隼利(DRIVE YOU CRAZY)(★4)
北海道_7番 中野 司(2021-22シーズン)(★4)
北海道_17番 山口 颯斗(2021-22シーズン)(★4)
秋田_12番 川嶋 勇人(2021-22シーズン)(★4)
秋田_16番 伊藤 駿(2021-22シーズン)(★4)
秋田_22番 多田 武史(2021-22シーズン)(★4)
秋田_24番 保岡 龍斗(2021-22シーズン)(★4)
茨城_7番 西川 貴之(2021-22シーズン)(★4)
茨城_8番 多嶋 朝飛(2021-22シーズン)(★4)
茨城_55番 谷口 大智(2021-22シーズン)(★4)
宇都宮_9番 遠藤 祐亮(2021-22シーズン)(★4)
宇都宮_11番 荒谷 裕秀(2021-22シーズン)(★4)
宇都宮_13番 渡邉 裕規(2021-22シーズン)(★4)
宇都宮_42番 アイザック・フォトゥ(2021-22シーズン)(★4)
群馬_4番 トレイ・ジョーンズ(2021-22シーズン)(★4)
群馬_7番 五十嵐 圭(2021-22シーズン)(★4)
群馬_14番 菅原 暉(2021-22シーズン)(★4)
群馬_15番 アキ・チェンバース(2021-22シーズン)(★4)
千葉_1番 ジョシュ・ダンカン(2021-22シーズン)(★4)
千葉_11番 西村 文男(2021-22シーズン)(★4)
千葉_14番 佐藤 卓磨(2021-22シーズン)(★4)
A東京_1番 小島 元基(2021-22シーズン)(★4)
A東京_9番 安藤 周人(2021-22シーズン)(★4)
A東京_22番 ライアン・ロシター(2021-22シーズン)(★4)
A東京_75番 小酒部 泰暉(2021-22シーズン)(★4)
SR渋谷_1番 関野 剛平(2021-22シーズン)(★4)
SR渋谷_9番 ベンドラメ 礼生(2021-22シーズン)(★4)
SR渋谷_14番 ジェームズ・マイケル・マカドゥ(2021-22シーズン)(★4)
SR渋谷_16番 渡辺 竜之佑(2021-22シーズン)(★4)
SR渋谷_44番 盛實 海翔(2021-22シーズン)(★4)
川崎_0番 藤井 祐眞(2021-22シーズン)(★4)
川崎_11番 増田 啓介(2021-22シーズン)(★4)
川崎_22番 ニック・ファジーカス(2021-22シーズン)(★4)
川崎_23番 マット・ジャニング(2021-22シーズン)(★4)
横浜_8番 古牧 昌也(2021-22シーズン)(★4)
横浜_9番 森川 正明(2021-22シーズン)(★4)
横浜_18番 森井 健太(2021-22シーズン)(★4)
新潟_0番 岡本 飛竜(2021-22シーズン)(★4)
新潟_21番 納見 悠仁(2021-22シーズン)(★4)
新潟_23番 佐藤 公威(2021-22シーズン)(★4)
新潟_34番 遠藤 善(2021-22シーズン)(★4)
富山_2番 飴谷 由毅(2021-22シーズン)(★4)
富山_7番 阿部 友和(2021-22シーズン)(★4)
富山_11番 宇都 直輝(2021-22シーズン)(★4)
富山_32番 ジュリアン・マブンガ(2021-22シーズン)(★4)
信州_8番 西山 達哉(2021-22シーズン)(★4)
信州_12番 栗原 ルイス(2021-22シーズン)(★4)
信州_77番 岡田 侑大(2021-22シーズン)(★4)
三遠_0番 サーディ・ラベナ(2021-22シーズン)(★4)
三遠_9番 杉浦 佑成(2021-22シーズン)(★4)
三遠_21番 田渡 凌(2021-22シーズン)(★4)
三河_7番 長野 誠史(2021-22シーズン)(★4)
三河_15番 根來 新之助(2021-22シーズン)(★4)
三河_54番 ダバンテ・ガードナー(2021-22シーズン)(★4)
名古屋D_3番 伊藤 達哉(2021-22シーズン)(★4)
名古屋D_8番 張本 天傑(2021-22シーズン)(★4)
名古屋D_32番 狩野 祐介(2021-22シーズン)(★4)
名古屋D_43番 スコット・エサトン(2021-22シーズン)(★4)
滋賀_3番 澁田 怜音(2021-22シーズン)(★4)
滋賀_14番 柏倉 哲平(2021-22シーズン)(★4)
滋賀_16番 野本 大智(2021-22シーズン)(★4)
滋賀_23番 ノヴァー・ガドソン(2021-22シーズン)(★4)
京都_25番 鈴木 達也(2021-22シーズン)(★4)
京都_32番 ジャスティン・ハーパー(2021-22シーズン)(★4)
京都_43番 永吉 佑也(2021-22シーズン)(★4)
京都_50番 デイヴィッド・サイモン(2021-22シーズン)(★4)
大阪_1番 青木 龍史(2021-22シーズン)(★4)
大阪_3番 エリエット・ドンリー(2021-22シーズン)(★4)
大阪_34番 ペリー・エリス(2021-22シーズン)(★4)
島根_2番 ぺリン・ビュフォード(2021-22シーズン)(★4)
島根_3番 安藤 誓哉(2021-22シーズン)(★4)
島根_4番 ニック・ケイ(2021-22シーズン)(★4)
島根_8番 リード・トラビス(2021-22シーズン)(★4)
広島_1番 トーマス・ケネディ(2021-22シーズン)(★4)
広島_2番 朝山 正悟(2021-22シーズン)(★4)
広島_3番 辻 直人(2021-22シーズン)(★4)
広島_4番 青木 保憲(2021-22シーズン)(★4)
琉球_4番 コー・フリッピン(2021-22シーズン)(★4)
琉球_14番 岸本 隆一(2021-22シーズン)(★4)
琉球_30番 今村 佳太(2021-22シーズン)(★4)
 
\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
 
\n ☆☆☆(レアカード)\n
北海道_0番 橋本 竜馬(2021-22シーズン)(★3)
北海道_4番 寺園 脩斗(2021-22シーズン)(★3)
北海道_5番 ダニエル・ミラー(2021-22シーズン)(★3)
北海道_15番 玉木 祥護(2021-22シーズン)(★3)
北海道_21番 ショーン・ロング(2021-22シーズン)(★3)
北海道_24番 デモン・ブルックス(2021-22シーズン)(★3)
秋田_3番 大浦 颯太(2021-22シーズン)(★3)
秋田_5番 田口 成浩(2021-22シーズン)(★3)
秋田_9番 アレックス・デイビス(2021-22シーズン)(★3)
秋田_17番 中山 拓哉(2021-22シーズン)(★3)
秋田_21番 長谷川 暢(2021-22シーズン)(★3)
秋田_51番 古川 孝敏(2021-22シーズン)(★3)
茨城_0番 遥 天翼(2021-22シーズン)(★3)
茨城_11番 チェハーレス・タプスコット(2021-22シーズン)(★3)
茨城_13番 中村 功平(2021-22シーズン)(★3)
茨城_15番 マーク・トラソリーニ(2021-22シーズン)(★3)
茨城_21番 エリック・ジェイコブセン(2021-22シーズン)(★3)
茨城_25番 平尾 充庸(2021-22シーズン)(★3)
茨城_29番 鶴巻 啓太(2021-22シーズン)(★3)
宇都宮_10番 竹内 公輔(2021-22シーズン)(★3)
宇都宮_18番 鵤 誠司(2021-22シーズン)(★3)
宇都宮_20番 チェイス・フィーラー(2021-22シーズン)(★3)
宇都宮_31番 喜多川 修平(2021-22シーズン)(★3)
宇都宮_40番 ジョシュ・スコット(2021-22シーズン)(★3)
群馬_3番 マイケル・パーカー(2021-22シーズン)(★3)
群馬_4番 トレイ・ジョーンズ(2021-22シーズン)(★3)
群馬_7番 五十嵐 圭(2021-22シーズン)(★3)
群馬_13番 笠井 康平(2021-22シーズン)(★3)
群馬_22番 上江田 勇樹(2021-22シーズン)(★3)
群馬_30番 山崎 稜(2021-22シーズン)(★3)
千葉_2番 富樫 勇樹(2021-22シーズン)(★3)
千葉_15番 藤永 佳昭(2021-22シーズン)(★3)
千葉_21番 ギャビン・エドワーズ(2021-22シーズン)(★3)
千葉_24番 ラシード ファラーズ(2021-22シーズン)(★3)
千葉_31番 原 修太(2021-22シーズン)(★3)
千葉_34番 クリストファー・スミス(2021-22シーズン)(★3)
A東京_1番 小島 元基(2021-22シーズン)(★3)
A東京_11番 セバスチャン・サイズ(2021-22シーズン)(★3)
A東京_13番 菊地 祥平(2021-22シーズン)(★3)
A東京_21番 平岩 玄(2021-22シーズン)(★3)
A東京_53番 アレックス・カーク(2021-22シーズン)(★3)
A東京_75番 小酒部 泰暉(2021-22シーズン)(★3)
SR渋谷_9番 ベンドラメ 礼生(2021-22シーズン)(★3)
SR渋谷_12番 西野 曜(2021-22シーズン)(★3)
SR渋谷_24番 広瀬 健太(2021-22シーズン)(★3)
SR渋谷_27番 石井 講祐(2021-22シーズン)(★3)
SR渋谷_55番 ジョシュ・ハレルソン(2021-22シーズン)(★3)
川崎_13番 前田 悟(2021-22シーズン)(★3)
川崎_18番 鎌田 裕也(2021-22シーズン)(★3)
川崎_20番 綱井 勇介(2021-22シーズン)(★3)
川崎_33番 長谷川 技(2021-22シーズン)(★3)
川崎_35番 ジョーダン・ヒース(2021-22シーズン)(★3)
横浜_1番 パトリック・アウダ(2021-22シーズン)(★3)
横浜_2番 レイトン・ハモンズ(2021-22シーズン)(★3)
横浜_14番 大庭 岳輝(2021-22シーズン)(★3)
横浜_17番 土屋 アリスター時生(2021-22シーズン)(★3)
横浜_18番 森井 健太(2021-22シーズン)(★3)
横浜_30番 須藤 昂矢(2021-22シーズン)(★3)
横浜_32番 エドワード・モリス(2021-22シーズン)(★3)
新潟_3番 大矢 孝太朗(2021-22シーズン)(★3)
新潟_4番 ジェフ・エアーズ(2021-22シーズン)(★3)
新潟_17番 綿貫 瞬(2021-22シーズン)(★3)
新潟_21番 納見 悠仁(2021-22シーズン)(★3)
新潟_25番 ロスコ・アレン(2021-22シーズン)(★3)
新潟_34番 遠藤 善(2021-22シーズン)(★3)
富山_2番 飴谷 由毅(2021-22シーズン)(★3)
富山_5番 ブライス・ジョンソン(2021-22シーズン)(★3)
富山_9番 水戸 健史(2021-22シーズン)(★3)
富山_10番 上澤 俊喜(2021-22シーズン)(★3)
富山_33番 晴山 ケビン(2021-22シーズン)(★3)
富山_34番 ジョシュア・スミス(2021-22シーズン)(★3)
信州_5番 ヤン ジェミン(2021-22シーズン)(★3)
信州_11番 熊谷 航(2021-22シーズン)(★3)
信州_15番 前田 怜緒(2021-22シーズン)(★3)
信州_19番 大崎 裕太(2021-22シーズン)(★3)
信州_31番 三ツ井 利也(2021-22シーズン)(★3)
信州_50番 ウェイン・マーシャル(2021-22シーズン)(★3)
三遠_0番 サーディ・ラベナ(2021-22シーズン)(★3)
三遠_13番 ジャスティン・ノックス(2021-22シーズン)(★3)
三遠_14番 松脇 圭志(2021-22シーズン)(★3)
三遠_20番 エリアス・ハリス(2021-22シーズン)(★3)
三遠_26番 津山 尚大(2021-22シーズン)(★3)
三遠_28番 津屋 一球(2021-22シーズン)(★3)
三遠_32番 山内 盛久(2021-22シーズン)(★3)
三河_3番 柏木 真介(2021-22シーズン)(★3)
三河_4番 細谷 将司(2021-22シーズン)(★3)
三河_5番 カイル・コリンズワース(2021-22シーズン)(★3)
三河_5番 カイル・コリンズワース(2021-22シーズン)(★3)
三河_19番 西田 優大(2021-22シーズン)(★3)
三河_21番 橋本 晃佑(2021-22シーズン)(★3)
三河_54番 ダバンテ・ガードナー(2021-22シーズン)(★3)
名古屋D_0番 小林 遥太(2021-22シーズン)(★3)
名古屋D_1番 レイ・パークスジュニア(2021-22シーズン)(★3)
名古屋D_3番 伊藤 達哉(2021-22シーズン)(★3)
名古屋D_11番 須田 侑太郎(2021-22シーズン)(★3)
名古屋D_12番 中東 泰斗(2021-22シーズン)(★3)
名古屋D_18番 中務 敏宏(2021-22シーズン)(★3)
滋賀_1番 オヴィ・ソコ(2021-22シーズン)(★3)
滋賀_15番 キーファー・ラベナ(2021-22シーズン)(★3)
滋賀_22番 トビン マーカス海舟(2021-22シーズン)(★3)
滋賀_54番 ショーン・オマラ(2021-22シーズン)(★3)
滋賀_77番 森山 修斗(2021-22シーズン)(★3)
京都_0番 ワース・スミス(2021-22シーズン)(★3)
京都_11番 久保田 義章(2021-22シーズン)(★3)
京都_21番 満田 丈太郎(2021-22シーズン)(★3)
京都_29番 細川 一輝(2021-22シーズン)(★3)
京都_31番 加藤 寿一(2021-22シーズン)(★3)
京都_32番 ジャスティン・ハーパー(2021-22シーズン)(★3)
大阪_2番 ケドリック・ストックマン・ジュニア(2021-22シーズン)(★3)
大阪_11番 ザック・モーア(2021-22シーズン)(★3)
大阪_15番 竹内 譲次(2021-22シーズン)(★3)
大阪_20番 合田 怜(2021-22シーズン)(★3)
大阪_24番 カイル・ハント(2021-22シーズン)(★3)
島根_6番 北川 弘(2021-22シーズン)(★3)
島根_8番 リード・トラビス(2021-22シーズン)(★3)
島根_28番 ウィリアムス ニカ(2021-22シーズン)(★3)
広島_4番 青木 保憲(2021-22シーズン)(★3)
広島_8番 グレゴリー・エチェニケ(2021-22シーズン)(★3)
広島_10番 チャールズ・ジャクソン(2021-22シーズン)(★3)
広島_14番 柳川 幹也(2021-22シーズン)(★3)
広島_24番 ニック・メイヨ(2021-22シーズン)(★3)
琉球_2番 小寺 ハミルトンゲイリー(2021-22シーズン)(★3)
琉球_7番 アレン・ダーラム(2021-22シーズン)(★3)
琉球_13番 ドウェイン・エバンス(2021-22シーズン)(★3)
琉球_30番 今村 佳太(2021-22シーズン)(★3)
琉球_34番 小野寺 祥太(2021-22シーズン)(★3)
琉球_45番 ジャック・クーリー(2021-22シーズン)(★3)
FE名古屋_1番 宮崎 恭行(2021-22シーズン)(★3)
香川_12番 アンガス・ブラント(2021-22シーズン)(★3)
愛媛_33番 俊野 達彦(2021-22シーズン)(★3)
熊本_14番 本村 亮輔(2021-22シーズン)(★3)
 
\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
 
\n ☆☆(エクストラカード)\n
秋田_16番 伊藤 駿(2021-22シーズン)(★2)
秋田_17番 中山 拓哉(2021-22シーズン)(★2)
秋田_21番 長谷川 暢(2021-22シーズン)(★2)
秋田_24番 保岡 龍斗(2021-22シーズン)(★2)
秋田_51番 古川 孝敏(2021-22シーズン)(★2)
茨城_2番 福澤 晃平(2021-22シーズン)(★2)
茨城_8番 多嶋 朝飛(2021-22シーズン)(★2)
茨城_11番 チェハーレス・タプスコット(2021-22シーズン)(★2)
茨城_13番 中村 功平(2021-22シーズン)(★2)
茨城_25番 平尾 充庸(2021-22シーズン)(★2)
宇都宮_0番 田臥 勇太(2021-22シーズン)(★2)
宇都宮_6番 比江島 慎(2021-22シーズン)(★2)
宇都宮_7番 テーブス 海(2021-22シーズン)(★2)
宇都宮_9番 遠藤 祐亮(2021-22シーズン)(★2)
宇都宮_13番 渡邉 裕規(2021-22シーズン)(★2)
群馬_3番 マイケル・パーカー(2021-22シーズン)(★2)
群馬_7番 五十嵐 圭(2021-22シーズン)(★2)
群馬_10番 杉本 天昇(2021-22シーズン)(★2)
群馬_30番 山崎 稜(2021-22シーズン)(★2)
群馬_40番 ジャスティン・キーナン(2021-22シーズン)(★2)
千葉_1番 ジョシュ・ダンカン(2021-22シーズン)(★2)
千葉_2番 富樫 勇樹(2021-22シーズン)(★2)
千葉_11番 西村 文男(2021-22シーズン)(★2)
千葉_21番 ギャビン・エドワーズ(2021-22シーズン)(★2)
千葉_31番 原 修太(2021-22シーズン)(★2)
A東京_9番 安藤 周人(2021-22シーズン)(★2)
A東京_10番 ザック・バランスキー(2021-22シーズン)(★2)
A東京_13番 菊地 祥平(2021-22シーズン)(★2)
A東京_24番 田中 大貴(2021-22シーズン)(★2)
A東京_75番 小酒部 泰暉(2021-22シーズン)(★2)
川崎_0番 藤井 祐眞(2021-22シーズン)(★2)
川崎_7番 篠山 竜青(2021-22シーズン)(★2)
川崎_11番 増田 啓介(2021-22シーズン)(★2)
川崎_22番 ニック・ファジーカス(2021-22シーズン)(★2)
川崎_27番 熊谷 尚也(2021-22シーズン)(★2)
横浜_1番 パトリック・アウダ(2021-22シーズン)(★2)
横浜_9番 森川 正明(2021-22シーズン)(★2)
横浜_18番 森井 健太(2021-22シーズン)(★2)
横浜_32番 エドワード・モリス(2021-22シーズン)(★2)
横浜_46番 生原 秀将(2021-22シーズン)(★2)
新潟_1番 星野 曹樹(2021-22シーズン)(★2)
新潟_3番 大矢 孝太朗(2021-22シーズン)(★2)
新潟_21番 納見 悠仁(2021-22シーズン)(★2)
新潟_23番 佐藤 公威(2021-22シーズン)(★2)
新潟_32番 池田 雄一(2021-22シーズン)(★2)
富山_1番 山口 祐希(2021-22シーズン)(★2)
富山_7番 阿部 友和(2021-22シーズン)(★2)
富山_9番 水戸 健史(2021-22シーズン)(★2)
富山_11番 宇都 直輝(2021-22シーズン)(★2)
富山_16番 松井 啓十郎(2021-22シーズン)(★2)
信州_5番 ヤン ジェミン(2021-22シーズン)(★2)
信州_8番 西山 達哉(2021-22シーズン)(★2)
信州_12番 栗原 ルイス(2021-22シーズン)(★2)
信州_50番 ウェイン・マーシャル(2021-22シーズン)(★2)
信州_55番 アンソニー・マクヘンリー(2021-22シーズン)(★2)
三遠_0番 サーディ・ラベナ(2021-22シーズン)(★2)
三遠_4番 ロバート・カーター(2021-22シーズン)(★2)
三遠_8番 太田 敦也(2021-22シーズン)(★2)
三遠_28番 津屋 一球(2021-22シーズン)(★2)
三遠_32番 山内 盛久(2021-22シーズン)(★2)
三河_3番 柏木 真介(2021-22シーズン)(★2)
三河_7番 長野 誠史(2021-22シーズン)(★2)
三河_15番 根來 新之助(2021-22シーズン)(★2)
三河_32番 シェーファー アヴィ幸樹(2021-22シーズン)(★2)
三河_54番 ダバンテ・ガードナー(2021-22シーズン)(★2)
名古屋D_0番 小林 遥太(2021-22シーズン)(★2)
名古屋D_2番 齋藤 拓実(2021-22シーズン)(★2)
名古屋D_3番 伊藤 達哉(2021-22シーズン)(★2)
名古屋D_11番 須田 侑太郎(2021-22シーズン)(★2)
名古屋D_12番 中東 泰斗(2021-22シーズン)(★2)
滋賀_3番 澁田 怜音(2021-22シーズン)(★2)
滋賀_14番 柏倉 哲平(2021-22シーズン)(★2)
滋賀_16番 野本 大智(2021-22シーズン)(★2)
滋賀_23番 ノヴァー・ガドソン(2021-22シーズン)(★2)
滋賀_33番 林 翔太郎(2021-22シーズン)(★2)
京都_11番 久保田 義章(2021-22シーズン)(★2)
京都_21番 満田 丈太郎(2021-22シーズン)(★2)
京都_29番 細川 一輝(2021-22シーズン)(★2)
京都_33番 内海 慎吾(2021-22シーズン)(★2)
京都_43番 永吉 佑也(2021-22シーズン)(★2)
大阪_1番 青木 龍史(2021-22シーズン)(★2)
大阪_3番 エリエット・ドンリー(2021-22シーズン)(★2)
大阪_14番 橋本 拓哉(2021-22シーズン)(★2)
大阪_15番 竹内 譲次(2021-22シーズン)(★2)
大阪_25番 ディージェイ・ニュービル(2021-22シーズン)(★2)
島根_2番 ぺリン・ビュフォード(2021-22シーズン)(★2)
島根_3番 安藤 誓哉(2021-22シーズン)(★2)
島根_5番 山下 泰弘(2021-22シーズン)(★2)
島根_6番 北川 弘(2021-22シーズン)(★2)
島根_14番 金丸 晃輔(2021-22シーズン)(★2)
広島_0番 寺嶋 良(2021-22シーズン)(★2)
広島_2番 朝山 正悟(2021-22シーズン)(★2)
広島_3番 辻 直人(2021-22シーズン)(★2)
広島_4番 青木 保憲(2021-22シーズン)(★2)
広島_5番 アイザイア・マーフィー(2021-22シーズン)(★2)
 
\n
\n
\n
\n \n
\n \n
\n
\n \n
\n\n\n\n\n
\n \n
\n \n \n \n" } } }; var schema = findNode('schema',schemaWrapper).schema; if (!schema) { schema = schemaWrapper.schema; } if (schema.$ref != null) { schema = defsParser.$refs.get(schema.$ref); } else if (schema.items != null && schema.items.$ref != null) { schema.items = defsParser.$refs.get(schema.items.$ref); } else { schemaWrapper.definitions = Object.assign({}, defs); $RefParser.dereference(schemaWrapper).catch(function(err) { console.log(err); }); } var view = new JSONSchemaView(schema, 3); $('#responses-Gacha-gachaDetailGachaIdGet-200-schema-data').val(JSON.stringify(schema)); var result = $('#responses-Gacha-gachaDetailGachaIdGet-schema-200'); result.empty(); result.append(view.render()); });
Name Type Format Description
Date String
ContentMinusType String
TransferMinusEncoding String
Connection String
Server String
XMinusPoweredMinusBy BigDecimal
Expires String
CacheMinusControl String
Pragma String

gachaGet

gacha


/gacha

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/gacha"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GachaApi;

import java.io.File;
import java.util.*;

public class GachaApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        GachaApi apiInstance = new GachaApi();

        try {
            apiInstance.gachaGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling GachaApi#gachaGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.GachaApi;

public class GachaApiExample {
    public static void main(String[] args) {
        GachaApi apiInstance = new GachaApi();

        try {
            apiInstance.gachaGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling GachaApi#gachaGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
GachaApi *apiInstance = [[GachaApi alloc] init];

// gacha
[apiInstance gachaGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.GachaApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.gachaGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class gachaGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new GachaApi();

            try {
                // gacha
                apiInstance.gachaGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling GachaApi.gachaGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GachaApi();

try {
    $api_instance->gachaGet();
} catch (Exception $e) {
    echo 'Exception when calling GachaApi->gachaGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GachaApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GachaApi->new();

eval {
    $api_instance->gachaGet();
};
if ($@) {
    warn "Exception when calling GachaApi->gachaGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.GachaApi()

try:
    # gacha
    api_instance.gacha_get()
except ApiException as e:
    print("Exception when calling GachaApi->gachaGet: %s\n" % e)
extern crate GachaApi;

pub fn main() {

    let mut context = GachaApi::Context::default();
    let result = client.gachaGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


gachaIndexApiGet

gacha/index_api


/gacha/index_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/gacha/index_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GachaApi;

import java.io.File;
import java.util.*;

public class GachaApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        GachaApi apiInstance = new GachaApi();

        try {
            apiInstance.gachaIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling GachaApi#gachaIndexApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.GachaApi;

public class GachaApiExample {
    public static void main(String[] args) {
        GachaApi apiInstance = new GachaApi();

        try {
            apiInstance.gachaIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling GachaApi#gachaIndexApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
GachaApi *apiInstance = [[GachaApi alloc] init];

// gacha/index_api
[apiInstance gachaIndexApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.GachaApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.gachaIndexApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class gachaIndexApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new GachaApi();

            try {
                // gacha/index_api
                apiInstance.gachaIndexApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling GachaApi.gachaIndexApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GachaApi();

try {
    $api_instance->gachaIndexApiGet();
} catch (Exception $e) {
    echo 'Exception when calling GachaApi->gachaIndexApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GachaApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GachaApi->new();

eval {
    $api_instance->gachaIndexApiGet();
};
if ($@) {
    warn "Exception when calling GachaApi->gachaIndexApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.GachaApi()

try:
    # gacha/index_api
    api_instance.gacha_index_api_get()
except ApiException as e:
    print("Exception when calling GachaApi->gachaIndexApiGet: %s\n" % e)
extern crate GachaApi;

pub fn main() {

    let mut context = GachaApi::Context::default();
    let result = client.gachaIndexApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


gachaResultApiGet

gacha/result_api


/gacha/result_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/gacha/result_api?rare_id=5&ids[0]=11111&cnt=10&gacha_id=2021077&new_card_ids[0]=11111"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GachaApi;

import java.io.File;
import java.util.*;

public class GachaApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        GachaApi apiInstance = new GachaApi();
        Integer rareId = 5; // Integer | 
        Integer idsLeft_Square_Bracket0Right_Square_Bracket = 11111; // Integer | 配列
ids[0]=value&ids[1]=value....
        Integer cnt = 10; // Integer | 
        Integer gachaId = 2021077; // Integer | 
        Integer newCardIdsLeft_Square_Bracket0Right_Square_Bracket = 11111; // Integer | 配列
new_card_ids[0]=value&new_card_ids[1]=value....

        try {
            apiInstance.gachaResultApiGet(rareId, idsLeft_Square_Bracket0Right_Square_Bracket, cnt, gachaId, newCardIdsLeft_Square_Bracket0Right_Square_Bracket);
        } catch (ApiException e) {
            System.err.println("Exception when calling GachaApi#gachaResultApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.GachaApi;

public class GachaApiExample {
    public static void main(String[] args) {
        GachaApi apiInstance = new GachaApi();
        Integer rareId = 5; // Integer | 
        Integer idsLeft_Square_Bracket0Right_Square_Bracket = 11111; // Integer | 配列
ids[0]=value&ids[1]=value....
        Integer cnt = 10; // Integer | 
        Integer gachaId = 2021077; // Integer | 
        Integer newCardIdsLeft_Square_Bracket0Right_Square_Bracket = 11111; // Integer | 配列
new_card_ids[0]=value&new_card_ids[1]=value....

        try {
            apiInstance.gachaResultApiGet(rareId, idsLeft_Square_Bracket0Right_Square_Bracket, cnt, gachaId, newCardIdsLeft_Square_Bracket0Right_Square_Bracket);
        } catch (ApiException e) {
            System.err.println("Exception when calling GachaApi#gachaResultApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
GachaApi *apiInstance = [[GachaApi alloc] init];
Integer *rareId = 5; //  (optional) (default to null)
Integer *idsLeft_Square_Bracket0Right_Square_Bracket = 11111; // 配列
ids[0]=value&ids[1]=value.... (optional) (default to null)
Integer *cnt = 10; //  (optional) (default to null)
Integer *gachaId = 2021077; //  (optional) (default to null)
Integer *newCardIdsLeft_Square_Bracket0Right_Square_Bracket = 11111; // 配列
new_card_ids[0]=value&new_card_ids[1]=value.... (optional) (default to null)

// gacha/result_api
[apiInstance gachaResultApiGetWith:rareId
    idsLeft_Square_Bracket0Right_Square_Bracket:idsLeft_Square_Bracket0Right_Square_Bracket
    cnt:cnt
    gachaId:gachaId
    newCardIdsLeft_Square_Bracket0Right_Square_Bracket:newCardIdsLeft_Square_Bracket0Right_Square_Bracket
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.GachaApi()
var opts = {
  'rareId': 5, // {Integer} 
  'idsLeft_Square_Bracket0Right_Square_Bracket': 11111, // {Integer} 配列
ids[0]=value&ids[1]=value....
  'cnt': 10, // {Integer} 
  'gachaId': 2021077, // {Integer} 
  'newCardIdsLeft_Square_Bracket0Right_Square_Bracket': 11111 // {Integer} 配列
new_card_ids[0]=value&new_card_ids[1]=value....
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.gachaResultApiGet(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class gachaResultApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new GachaApi();
            var rareId = 5;  // Integer |  (optional)  (default to null)
            var idsLeft_Square_Bracket0Right_Square_Bracket = 11111;  // Integer | 配列
ids[0]=value&ids[1]=value.... (optional)  (default to null)
            var cnt = 10;  // Integer |  (optional)  (default to null)
            var gachaId = 2021077;  // Integer |  (optional)  (default to null)
            var newCardIdsLeft_Square_Bracket0Right_Square_Bracket = 11111;  // Integer | 配列
new_card_ids[0]=value&new_card_ids[1]=value.... (optional)  (default to null)

            try {
                // gacha/result_api
                apiInstance.gachaResultApiGet(rareId, idsLeft_Square_Bracket0Right_Square_Bracket, cnt, gachaId, newCardIdsLeft_Square_Bracket0Right_Square_Bracket);
            } catch (Exception e) {
                Debug.Print("Exception when calling GachaApi.gachaResultApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GachaApi();
$rareId = 5; // Integer | 
$idsLeft_Square_Bracket0Right_Square_Bracket = 11111; // Integer | 配列
ids[0]=value&ids[1]=value....
$cnt = 10; // Integer | 
$gachaId = 2021077; // Integer | 
$newCardIdsLeft_Square_Bracket0Right_Square_Bracket = 11111; // Integer | 配列
new_card_ids[0]=value&new_card_ids[1]=value....

try {
    $api_instance->gachaResultApiGet($rareId, $idsLeft_Square_Bracket0Right_Square_Bracket, $cnt, $gachaId, $newCardIdsLeft_Square_Bracket0Right_Square_Bracket);
} catch (Exception $e) {
    echo 'Exception when calling GachaApi->gachaResultApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GachaApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GachaApi->new();
my $rareId = 5; # Integer | 
my $idsLeft_Square_Bracket0Right_Square_Bracket = 11111; # Integer | 配列
ids[0]=value&ids[1]=value....
my $cnt = 10; # Integer | 
my $gachaId = 2021077; # Integer | 
my $newCardIdsLeft_Square_Bracket0Right_Square_Bracket = 11111; # Integer | 配列
new_card_ids[0]=value&new_card_ids[1]=value....

eval {
    $api_instance->gachaResultApiGet(rareId => $rareId, idsLeft_Square_Bracket0Right_Square_Bracket => $idsLeft_Square_Bracket0Right_Square_Bracket, cnt => $cnt, gachaId => $gachaId, newCardIdsLeft_Square_Bracket0Right_Square_Bracket => $newCardIdsLeft_Square_Bracket0Right_Square_Bracket);
};
if ($@) {
    warn "Exception when calling GachaApi->gachaResultApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.GachaApi()
rareId = 5 # Integer |  (optional) (default to null)
idsLeft_Square_Bracket0Right_Square_Bracket = 11111 # Integer | 配列
ids[0]=value&ids[1]=value.... (optional) (default to null)
cnt = 10 # Integer |  (optional) (default to null)
gachaId = 2021077 # Integer |  (optional) (default to null)
newCardIdsLeft_Square_Bracket0Right_Square_Bracket = 11111 # Integer | 配列
new_card_ids[0]=value&new_card_ids[1]=value.... (optional) (default to null)

try:
    # gacha/result_api
    api_instance.gacha_result_api_get(rareId=rareId, idsLeft_Square_Bracket0Right_Square_Bracket=idsLeft_Square_Bracket0Right_Square_Bracket, cnt=cnt, gachaId=gachaId, newCardIdsLeft_Square_Bracket0Right_Square_Bracket=newCardIdsLeft_Square_Bracket0Right_Square_Bracket)
except ApiException as e:
    print("Exception when calling GachaApi->gachaResultApiGet: %s\n" % e)
extern crate GachaApi;

pub fn main() {
    let rareId = 5; // Integer
    let idsLeft_Square_Bracket0Right_Square_Bracket = 11111; // Integer
    let cnt = 10; // Integer
    let gachaId = 2021077; // Integer
    let newCardIdsLeft_Square_Bracket0Right_Square_Bracket = 11111; // Integer

    let mut context = GachaApi::Context::default();
    let result = client.gachaResultApiGet(rareId, idsLeft_Square_Bracket0Right_Square_Bracket, cnt, gachaId, newCardIdsLeft_Square_Bracket0Right_Square_Bracket, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
rare_id
Integer
ids[0]
Integer
配列 ids[0]=value&ids[1]=value....
cnt
Integer
gacha_id
Integer
new_card_ids[0]
Integer
配列 new_card_ids[0]=value&new_card_ids[1]=value....

Responses


gachaResultGet

gacha/result


/gacha/result

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/gacha/result?rare_id=5&ids[0]=11111&cnt=10&gacha_id=2021077&new_card_ids[0]=11111"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GachaApi;

import java.io.File;
import java.util.*;

public class GachaApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        GachaApi apiInstance = new GachaApi();
        Integer rareId = 5; // Integer | 
        Integer idsLeft_Square_Bracket0Right_Square_Bracket = 11111; // Integer | 配列
ids[0]=value&ids[1]=value....
        Integer cnt = 10; // Integer | 
        Integer gachaId = 2021077; // Integer | 
        Integer newCardIdsLeft_Square_Bracket0Right_Square_Bracket = 11111; // Integer | 配列
new_card_ids[0]=value&new_card_ids[1]=value....

        try {
            apiInstance.gachaResultGet(rareId, idsLeft_Square_Bracket0Right_Square_Bracket, cnt, gachaId, newCardIdsLeft_Square_Bracket0Right_Square_Bracket);
        } catch (ApiException e) {
            System.err.println("Exception when calling GachaApi#gachaResultGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.GachaApi;

public class GachaApiExample {
    public static void main(String[] args) {
        GachaApi apiInstance = new GachaApi();
        Integer rareId = 5; // Integer | 
        Integer idsLeft_Square_Bracket0Right_Square_Bracket = 11111; // Integer | 配列
ids[0]=value&ids[1]=value....
        Integer cnt = 10; // Integer | 
        Integer gachaId = 2021077; // Integer | 
        Integer newCardIdsLeft_Square_Bracket0Right_Square_Bracket = 11111; // Integer | 配列
new_card_ids[0]=value&new_card_ids[1]=value....

        try {
            apiInstance.gachaResultGet(rareId, idsLeft_Square_Bracket0Right_Square_Bracket, cnt, gachaId, newCardIdsLeft_Square_Bracket0Right_Square_Bracket);
        } catch (ApiException e) {
            System.err.println("Exception when calling GachaApi#gachaResultGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
GachaApi *apiInstance = [[GachaApi alloc] init];
Integer *rareId = 5; //  (optional) (default to null)
Integer *idsLeft_Square_Bracket0Right_Square_Bracket = 11111; // 配列
ids[0]=value&ids[1]=value.... (optional) (default to null)
Integer *cnt = 10; //  (optional) (default to null)
Integer *gachaId = 2021077; //  (optional) (default to null)
Integer *newCardIdsLeft_Square_Bracket0Right_Square_Bracket = 11111; // 配列
new_card_ids[0]=value&new_card_ids[1]=value.... (optional) (default to null)

// gacha/result
[apiInstance gachaResultGetWith:rareId
    idsLeft_Square_Bracket0Right_Square_Bracket:idsLeft_Square_Bracket0Right_Square_Bracket
    cnt:cnt
    gachaId:gachaId
    newCardIdsLeft_Square_Bracket0Right_Square_Bracket:newCardIdsLeft_Square_Bracket0Right_Square_Bracket
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.GachaApi()
var opts = {
  'rareId': 5, // {Integer} 
  'idsLeft_Square_Bracket0Right_Square_Bracket': 11111, // {Integer} 配列
ids[0]=value&ids[1]=value....
  'cnt': 10, // {Integer} 
  'gachaId': 2021077, // {Integer} 
  'newCardIdsLeft_Square_Bracket0Right_Square_Bracket': 11111 // {Integer} 配列
new_card_ids[0]=value&new_card_ids[1]=value....
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.gachaResultGet(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class gachaResultGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new GachaApi();
            var rareId = 5;  // Integer |  (optional)  (default to null)
            var idsLeft_Square_Bracket0Right_Square_Bracket = 11111;  // Integer | 配列
ids[0]=value&ids[1]=value.... (optional)  (default to null)
            var cnt = 10;  // Integer |  (optional)  (default to null)
            var gachaId = 2021077;  // Integer |  (optional)  (default to null)
            var newCardIdsLeft_Square_Bracket0Right_Square_Bracket = 11111;  // Integer | 配列
new_card_ids[0]=value&new_card_ids[1]=value.... (optional)  (default to null)

            try {
                // gacha/result
                apiInstance.gachaResultGet(rareId, idsLeft_Square_Bracket0Right_Square_Bracket, cnt, gachaId, newCardIdsLeft_Square_Bracket0Right_Square_Bracket);
            } catch (Exception e) {
                Debug.Print("Exception when calling GachaApi.gachaResultGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GachaApi();
$rareId = 5; // Integer | 
$idsLeft_Square_Bracket0Right_Square_Bracket = 11111; // Integer | 配列
ids[0]=value&ids[1]=value....
$cnt = 10; // Integer | 
$gachaId = 2021077; // Integer | 
$newCardIdsLeft_Square_Bracket0Right_Square_Bracket = 11111; // Integer | 配列
new_card_ids[0]=value&new_card_ids[1]=value....

try {
    $api_instance->gachaResultGet($rareId, $idsLeft_Square_Bracket0Right_Square_Bracket, $cnt, $gachaId, $newCardIdsLeft_Square_Bracket0Right_Square_Bracket);
} catch (Exception $e) {
    echo 'Exception when calling GachaApi->gachaResultGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GachaApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GachaApi->new();
my $rareId = 5; # Integer | 
my $idsLeft_Square_Bracket0Right_Square_Bracket = 11111; # Integer | 配列
ids[0]=value&ids[1]=value....
my $cnt = 10; # Integer | 
my $gachaId = 2021077; # Integer | 
my $newCardIdsLeft_Square_Bracket0Right_Square_Bracket = 11111; # Integer | 配列
new_card_ids[0]=value&new_card_ids[1]=value....

eval {
    $api_instance->gachaResultGet(rareId => $rareId, idsLeft_Square_Bracket0Right_Square_Bracket => $idsLeft_Square_Bracket0Right_Square_Bracket, cnt => $cnt, gachaId => $gachaId, newCardIdsLeft_Square_Bracket0Right_Square_Bracket => $newCardIdsLeft_Square_Bracket0Right_Square_Bracket);
};
if ($@) {
    warn "Exception when calling GachaApi->gachaResultGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.GachaApi()
rareId = 5 # Integer |  (optional) (default to null)
idsLeft_Square_Bracket0Right_Square_Bracket = 11111 # Integer | 配列
ids[0]=value&ids[1]=value.... (optional) (default to null)
cnt = 10 # Integer |  (optional) (default to null)
gachaId = 2021077 # Integer |  (optional) (default to null)
newCardIdsLeft_Square_Bracket0Right_Square_Bracket = 11111 # Integer | 配列
new_card_ids[0]=value&new_card_ids[1]=value.... (optional) (default to null)

try:
    # gacha/result
    api_instance.gacha_result_get(rareId=rareId, idsLeft_Square_Bracket0Right_Square_Bracket=idsLeft_Square_Bracket0Right_Square_Bracket, cnt=cnt, gachaId=gachaId, newCardIdsLeft_Square_Bracket0Right_Square_Bracket=newCardIdsLeft_Square_Bracket0Right_Square_Bracket)
except ApiException as e:
    print("Exception when calling GachaApi->gachaResultGet: %s\n" % e)
extern crate GachaApi;

pub fn main() {
    let rareId = 5; // Integer
    let idsLeft_Square_Bracket0Right_Square_Bracket = 11111; // Integer
    let cnt = 10; // Integer
    let gachaId = 2021077; // Integer
    let newCardIdsLeft_Square_Bracket0Right_Square_Bracket = 11111; // Integer

    let mut context = GachaApi::Context::default();
    let result = client.gachaResultGet(rareId, idsLeft_Square_Bracket0Right_Square_Bracket, cnt, gachaId, newCardIdsLeft_Square_Bracket0Right_Square_Bracket, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
rare_id
Integer
ids[0]
Integer
配列 ids[0]=value&ids[1]=value....
cnt
Integer
gacha_id
Integer
new_card_ids[0]
Integer
配列 new_card_ids[0]=value&new_card_ids[1]=value....

Responses


Information

informationGet

information


/information

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/information"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.InformationApi;

import java.io.File;
import java.util.*;

public class InformationApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        InformationApi apiInstance = new InformationApi();

        try {
            apiInstance.informationGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling InformationApi#informationGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.InformationApi;

public class InformationApiExample {
    public static void main(String[] args) {
        InformationApi apiInstance = new InformationApi();

        try {
            apiInstance.informationGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling InformationApi#informationGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
InformationApi *apiInstance = [[InformationApi alloc] init];

// information
[apiInstance informationGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.InformationApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.informationGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class informationGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new InformationApi();

            try {
                // information
                apiInstance.informationGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling InformationApi.informationGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\InformationApi();

try {
    $api_instance->informationGet();
} catch (Exception $e) {
    echo 'Exception when calling InformationApi->informationGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::InformationApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::InformationApi->new();

eval {
    $api_instance->informationGet();
};
if ($@) {
    warn "Exception when calling InformationApi->informationGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.InformationApi()

try:
    # information
    api_instance.information_get()
except ApiException as e:
    print("Exception when calling InformationApi->informationGet: %s\n" % e)
extern crate InformationApi;

pub fn main() {

    let mut context = InformationApi::Context::default();
    let result = client.informationGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


informationJsonGet

information/json


/information/json

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/information/json"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.InformationApi;

import java.io.File;
import java.util.*;

public class InformationApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        InformationApi apiInstance = new InformationApi();

        try {
            apiInstance.informationJsonGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling InformationApi#informationJsonGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.InformationApi;

public class InformationApiExample {
    public static void main(String[] args) {
        InformationApi apiInstance = new InformationApi();

        try {
            apiInstance.informationJsonGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling InformationApi#informationJsonGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
InformationApi *apiInstance = [[InformationApi alloc] init];

// information/json
[apiInstance informationJsonGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.InformationApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.informationJsonGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class informationJsonGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new InformationApi();

            try {
                // information/json
                apiInstance.informationJsonGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling InformationApi.informationJsonGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\InformationApi();

try {
    $api_instance->informationJsonGet();
} catch (Exception $e) {
    echo 'Exception when calling InformationApi->informationJsonGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::InformationApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::InformationApi->new();

eval {
    $api_instance->informationJsonGet();
};
if ($@) {
    warn "Exception when calling InformationApi->informationJsonGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.InformationApi()

try:
    # information/json
    api_instance.information_json_get()
except ApiException as e:
    print("Exception when calling InformationApi->informationJsonGet: %s\n" % e)
extern crate InformationApi;

pub fn main() {

    let mut context = InformationApi::Context::default();
    let result = client.informationJsonGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


JsMaster

jsMasterCardsPackedExTargetYearGet

js_master/cards_packed_ex/:target_year


/js_master/cards_packed_ex/{target_year}

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: text/plain" \
 "http://localhost/js_master/cards_packed_ex/{target_year}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.JsMasterApi;

import java.io.File;
import java.util.*;

public class JsMasterApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        JsMasterApi apiInstance = new JsMasterApi();
        String targetYear = targetYear_example; // String | 入力なしだと最新年度のカード

        try {
            'String' result = apiInstance.jsMasterCardsPackedExTargetYearGet(targetYear);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JsMasterApi#jsMasterCardsPackedExTargetYearGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.JsMasterApi;

public class JsMasterApiExample {
    public static void main(String[] args) {
        JsMasterApi apiInstance = new JsMasterApi();
        String targetYear = targetYear_example; // String | 入力なしだと最新年度のカード

        try {
            'String' result = apiInstance.jsMasterCardsPackedExTargetYearGet(targetYear);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JsMasterApi#jsMasterCardsPackedExTargetYearGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
JsMasterApi *apiInstance = [[JsMasterApi alloc] init];
String *targetYear = targetYear_example; // 入力なしだと最新年度のカード (default to null)

// js_master/cards_packed_ex/:target_year
[apiInstance jsMasterCardsPackedExTargetYearGetWith:targetYear
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.JsMasterApi()
var targetYear = targetYear_example; // {String} 入力なしだと最新年度のカード

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.jsMasterCardsPackedExTargetYearGet(targetYear, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class jsMasterCardsPackedExTargetYearGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new JsMasterApi();
            var targetYear = targetYear_example;  // String | 入力なしだと最新年度のカード (default to null)

            try {
                // js_master/cards_packed_ex/:target_year
                'String' result = apiInstance.jsMasterCardsPackedExTargetYearGet(targetYear);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling JsMasterApi.jsMasterCardsPackedExTargetYearGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\JsMasterApi();
$targetYear = targetYear_example; // String | 入力なしだと最新年度のカード

try {
    $result = $api_instance->jsMasterCardsPackedExTargetYearGet($targetYear);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling JsMasterApi->jsMasterCardsPackedExTargetYearGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::JsMasterApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::JsMasterApi->new();
my $targetYear = targetYear_example; # String | 入力なしだと最新年度のカード

eval {
    my $result = $api_instance->jsMasterCardsPackedExTargetYearGet(targetYear => $targetYear);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling JsMasterApi->jsMasterCardsPackedExTargetYearGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.JsMasterApi()
targetYear = targetYear_example # String | 入力なしだと最新年度のカード (default to null)

try:
    # js_master/cards_packed_ex/:target_year
    api_response = api_instance.js_master_cards_packed_ex_target_year_get(targetYear)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JsMasterApi->jsMasterCardsPackedExTargetYearGet: %s\n" % e)
extern crate JsMasterApi;

pub fn main() {
    let targetYear = targetYear_example; // String

    let mut context = JsMasterApi::Context::default();
    let result = client.jsMasterCardsPackedExTargetYearGet(targetYear, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
target_year*
String
入力なしだと最新年度のカード
Required

Responses

Name Type Format Description
Date String
ContentMinusType String
TransferMinusEncoding String
Connection String
Server String
XMinusPoweredMinusBy BigDecimal
CacheMinusControl String
Expires String
ETag Integer

jsMasterCardsPackedTargetYearGet

js_master/cards_packed/:target_year


/js_master/cards_packed/{target_year}

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: text/plain" \
 "http://localhost/js_master/cards_packed/{target_year}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.JsMasterApi;

import java.io.File;
import java.util.*;

public class JsMasterApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        JsMasterApi apiInstance = new JsMasterApi();
        String targetYear = targetYear_example; // String | 入力なしだと最新の年度のカード

        try {
            'String' result = apiInstance.jsMasterCardsPackedTargetYearGet(targetYear);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JsMasterApi#jsMasterCardsPackedTargetYearGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.JsMasterApi;

public class JsMasterApiExample {
    public static void main(String[] args) {
        JsMasterApi apiInstance = new JsMasterApi();
        String targetYear = targetYear_example; // String | 入力なしだと最新の年度のカード

        try {
            'String' result = apiInstance.jsMasterCardsPackedTargetYearGet(targetYear);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JsMasterApi#jsMasterCardsPackedTargetYearGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
JsMasterApi *apiInstance = [[JsMasterApi alloc] init];
String *targetYear = targetYear_example; // 入力なしだと最新の年度のカード (default to null)

// js_master/cards_packed/:target_year
[apiInstance jsMasterCardsPackedTargetYearGetWith:targetYear
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.JsMasterApi()
var targetYear = targetYear_example; // {String} 入力なしだと最新の年度のカード

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.jsMasterCardsPackedTargetYearGet(targetYear, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class jsMasterCardsPackedTargetYearGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new JsMasterApi();
            var targetYear = targetYear_example;  // String | 入力なしだと最新の年度のカード (default to null)

            try {
                // js_master/cards_packed/:target_year
                'String' result = apiInstance.jsMasterCardsPackedTargetYearGet(targetYear);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling JsMasterApi.jsMasterCardsPackedTargetYearGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\JsMasterApi();
$targetYear = targetYear_example; // String | 入力なしだと最新の年度のカード

try {
    $result = $api_instance->jsMasterCardsPackedTargetYearGet($targetYear);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling JsMasterApi->jsMasterCardsPackedTargetYearGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::JsMasterApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::JsMasterApi->new();
my $targetYear = targetYear_example; # String | 入力なしだと最新の年度のカード

eval {
    my $result = $api_instance->jsMasterCardsPackedTargetYearGet(targetYear => $targetYear);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling JsMasterApi->jsMasterCardsPackedTargetYearGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.JsMasterApi()
targetYear = targetYear_example # String | 入力なしだと最新の年度のカード (default to null)

try:
    # js_master/cards_packed/:target_year
    api_response = api_instance.js_master_cards_packed_target_year_get(targetYear)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JsMasterApi->jsMasterCardsPackedTargetYearGet: %s\n" % e)
extern crate JsMasterApi;

pub fn main() {
    let targetYear = targetYear_example; // String

    let mut context = JsMasterApi::Context::default();
    let result = client.jsMasterCardsPackedTargetYearGet(targetYear, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
target_year*
String
入力なしだと最新の年度のカード
Required

Responses

Name Type Format Description
Date String
ContentMinusType String
TransferMinusEncoding String
Connection String
Server String
XMinusPoweredMinusBy BigDecimal
CacheMinusControl String
Expires String
ETag Integer

jsMasterCardsTargetYearGet

js_master/cards/:target_year


/js_master/cards/{target_year}

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: text/plain" \
 "http://localhost/js_master/cards/{target_year}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.JsMasterApi;

import java.io.File;
import java.util.*;

public class JsMasterApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        JsMasterApi apiInstance = new JsMasterApi();
        String targetYear = targetYear_example; // String | 入力なしだと最新の年度のカード

        try {
            'String' result = apiInstance.jsMasterCardsTargetYearGet(targetYear);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JsMasterApi#jsMasterCardsTargetYearGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.JsMasterApi;

public class JsMasterApiExample {
    public static void main(String[] args) {
        JsMasterApi apiInstance = new JsMasterApi();
        String targetYear = targetYear_example; // String | 入力なしだと最新の年度のカード

        try {
            'String' result = apiInstance.jsMasterCardsTargetYearGet(targetYear);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JsMasterApi#jsMasterCardsTargetYearGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
JsMasterApi *apiInstance = [[JsMasterApi alloc] init];
String *targetYear = targetYear_example; // 入力なしだと最新の年度のカード (default to null)

// js_master/cards/:target_year
[apiInstance jsMasterCardsTargetYearGetWith:targetYear
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.JsMasterApi()
var targetYear = targetYear_example; // {String} 入力なしだと最新の年度のカード

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.jsMasterCardsTargetYearGet(targetYear, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class jsMasterCardsTargetYearGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new JsMasterApi();
            var targetYear = targetYear_example;  // String | 入力なしだと最新の年度のカード (default to null)

            try {
                // js_master/cards/:target_year
                'String' result = apiInstance.jsMasterCardsTargetYearGet(targetYear);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling JsMasterApi.jsMasterCardsTargetYearGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\JsMasterApi();
$targetYear = targetYear_example; // String | 入力なしだと最新の年度のカード

try {
    $result = $api_instance->jsMasterCardsTargetYearGet($targetYear);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling JsMasterApi->jsMasterCardsTargetYearGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::JsMasterApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::JsMasterApi->new();
my $targetYear = targetYear_example; # String | 入力なしだと最新の年度のカード

eval {
    my $result = $api_instance->jsMasterCardsTargetYearGet(targetYear => $targetYear);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling JsMasterApi->jsMasterCardsTargetYearGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.JsMasterApi()
targetYear = targetYear_example # String | 入力なしだと最新の年度のカード (default to null)

try:
    # js_master/cards/:target_year
    api_response = api_instance.js_master_cards_target_year_get(targetYear)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JsMasterApi->jsMasterCardsTargetYearGet: %s\n" % e)
extern crate JsMasterApi;

pub fn main() {
    let targetYear = targetYear_example; // String

    let mut context = JsMasterApi::Context::default();
    let result = client.jsMasterCardsTargetYearGet(targetYear, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
target_year*
String
入力なしだと最新の年度のカード
Required

Responses

Name Type Format Description
Date String
ContentMinusType String
ContentMinusLength Integer
Connection String
Server String
XMinusPoweredMinusBy BigDecimal
CacheMinusControl String
Expires String
ETag Integer

Koukan

koukanApiGet

koukan_api


/koukan_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/koukan_api?user_id=11890576&card_id=20417"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KoukanApi;

import java.io.File;
import java.util.*;

public class KoukanApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        KoukanApi apiInstance = new KoukanApi();
        Integer userId = 11890576; // Integer | 対象ユーザーID
        Integer cardId = 20417; // Integer | こちらが交換に出すID

        try {
            apiInstance.koukanApiGet(userId, cardId);
        } catch (ApiException e) {
            System.err.println("Exception when calling KoukanApi#koukanApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.KoukanApi;

public class KoukanApiExample {
    public static void main(String[] args) {
        KoukanApi apiInstance = new KoukanApi();
        Integer userId = 11890576; // Integer | 対象ユーザーID
        Integer cardId = 20417; // Integer | こちらが交換に出すID

        try {
            apiInstance.koukanApiGet(userId, cardId);
        } catch (ApiException e) {
            System.err.println("Exception when calling KoukanApi#koukanApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
KoukanApi *apiInstance = [[KoukanApi alloc] init];
Integer *userId = 11890576; // 対象ユーザーID (optional) (default to null)
Integer *cardId = 20417; // こちらが交換に出すID (optional) (default to null)

// koukan_api
[apiInstance koukanApiGetWith:userId
    cardId:cardId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.KoukanApi()
var opts = {
  'userId': 11890576, // {Integer} 対象ユーザーID
  'cardId': 20417 // {Integer} こちらが交換に出すID
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.koukanApiGet(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class koukanApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new KoukanApi();
            var userId = 11890576;  // Integer | 対象ユーザーID (optional)  (default to null)
            var cardId = 20417;  // Integer | こちらが交換に出すID (optional)  (default to null)

            try {
                // koukan_api
                apiInstance.koukanApiGet(userId, cardId);
            } catch (Exception e) {
                Debug.Print("Exception when calling KoukanApi.koukanApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KoukanApi();
$userId = 11890576; // Integer | 対象ユーザーID
$cardId = 20417; // Integer | こちらが交換に出すID

try {
    $api_instance->koukanApiGet($userId, $cardId);
} catch (Exception $e) {
    echo 'Exception when calling KoukanApi->koukanApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KoukanApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KoukanApi->new();
my $userId = 11890576; # Integer | 対象ユーザーID
my $cardId = 20417; # Integer | こちらが交換に出すID

eval {
    $api_instance->koukanApiGet(userId => $userId, cardId => $cardId);
};
if ($@) {
    warn "Exception when calling KoukanApi->koukanApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.KoukanApi()
userId = 11890576 # Integer | 対象ユーザーID (optional) (default to null)
cardId = 20417 # Integer | こちらが交換に出すID (optional) (default to null)

try:
    # koukan_api
    api_instance.koukan_api_get(userId=userId, cardId=cardId)
except ApiException as e:
    print("Exception when calling KoukanApi->koukanApiGet: %s\n" % e)
extern crate KoukanApi;

pub fn main() {
    let userId = 11890576; // Integer
    let cardId = 20417; // Integer

    let mut context = KoukanApi::Context::default();
    let result = client.koukanApiGet(userId, cardId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
user_id
Integer
対象ユーザーID
card_id
Integer
こちらが交換に出すID

Responses


koukanGet

koukan


/koukan

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/koukan?user_id=11890576&card_id=20417"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KoukanApi;

import java.io.File;
import java.util.*;

public class KoukanApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        KoukanApi apiInstance = new KoukanApi();
        Integer userId = 11890576; // Integer | 対象ユーザーID
        Integer cardId = 20417; // Integer | こちらが交換に出すID

        try {
            apiInstance.koukanGet(userId, cardId);
        } catch (ApiException e) {
            System.err.println("Exception when calling KoukanApi#koukanGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.KoukanApi;

public class KoukanApiExample {
    public static void main(String[] args) {
        KoukanApi apiInstance = new KoukanApi();
        Integer userId = 11890576; // Integer | 対象ユーザーID
        Integer cardId = 20417; // Integer | こちらが交換に出すID

        try {
            apiInstance.koukanGet(userId, cardId);
        } catch (ApiException e) {
            System.err.println("Exception when calling KoukanApi#koukanGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
KoukanApi *apiInstance = [[KoukanApi alloc] init];
Integer *userId = 11890576; // 対象ユーザーID (optional) (default to null)
Integer *cardId = 20417; // こちらが交換に出すID (optional) (default to null)

// koukan
[apiInstance koukanGetWith:userId
    cardId:cardId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.KoukanApi()
var opts = {
  'userId': 11890576, // {Integer} 対象ユーザーID
  'cardId': 20417 // {Integer} こちらが交換に出すID
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.koukanGet(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class koukanGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new KoukanApi();
            var userId = 11890576;  // Integer | 対象ユーザーID (optional)  (default to null)
            var cardId = 20417;  // Integer | こちらが交換に出すID (optional)  (default to null)

            try {
                // koukan
                apiInstance.koukanGet(userId, cardId);
            } catch (Exception e) {
                Debug.Print("Exception when calling KoukanApi.koukanGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KoukanApi();
$userId = 11890576; // Integer | 対象ユーザーID
$cardId = 20417; // Integer | こちらが交換に出すID

try {
    $api_instance->koukanGet($userId, $cardId);
} catch (Exception $e) {
    echo 'Exception when calling KoukanApi->koukanGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KoukanApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KoukanApi->new();
my $userId = 11890576; # Integer | 対象ユーザーID
my $cardId = 20417; # Integer | こちらが交換に出すID

eval {
    $api_instance->koukanGet(userId => $userId, cardId => $cardId);
};
if ($@) {
    warn "Exception when calling KoukanApi->koukanGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.KoukanApi()
userId = 11890576 # Integer | 対象ユーザーID (optional) (default to null)
cardId = 20417 # Integer | こちらが交換に出すID (optional) (default to null)

try:
    # koukan
    api_instance.koukan_get(userId=userId, cardId=cardId)
except ApiException as e:
    print("Exception when calling KoukanApi->koukanGet: %s\n" % e)
extern crate KoukanApi;

pub fn main() {
    let userId = 11890576; // Integer
    let cardId = 20417; // Integer

    let mut context = KoukanApi::Context::default();
    let result = client.koukanGet(userId, cardId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
user_id
Integer
対象ユーザーID
card_id
Integer
こちらが交換に出すID

Responses


Login

rootPost

Login


/

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LoginApi;

import java.io.File;
import java.util.*;

public class LoginApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        LoginApi apiInstance = new LoginApi();
        Object body = Object; // Object | 

        try {
            apiInstance.rootPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginApi#rootPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.LoginApi;

public class LoginApiExample {
    public static void main(String[] args) {
        LoginApi apiInstance = new LoginApi();
        Object body = Object; // Object | 

        try {
            apiInstance.rootPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginApi#rootPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
LoginApi *apiInstance = [[LoginApi alloc] init];
Object *body = Object; //  (optional)

// Login
[apiInstance rootPostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.LoginApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.rootPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class rootPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new LoginApi();
            var body = Object;  // Object |  (optional) 

            try {
                // Login
                apiInstance.rootPost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginApi.rootPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LoginApi();
$body = Object; // Object | 

try {
    $api_instance->rootPost($body);
} catch (Exception $e) {
    echo 'Exception when calling LoginApi->rootPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LoginApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LoginApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->rootPost(body => $body);
};
if ($@) {
    warn "Exception when calling LoginApi->rootPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.LoginApi()
body = Object # Object |  (optional)

try:
    # Login
    api_instance.root_post(body=body)
except ApiException as e:
    print("Exception when calling LoginApi->rootPost: %s\n" % e)
extern crate LoginApi;

pub fn main() {
    let body = Object; // Object

    let mut context = LoginApi::Context::default();
    let result = client.rootPost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


MascotVote

mascotVoteGet

mascot_vote


/mascot_vote

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/mascot_vote?target_year=yyyy"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MascotVoteApi;

import java.io.File;
import java.util.*;

public class MascotVoteApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        MascotVoteApi apiInstance = new MascotVoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.mascotVoteGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling MascotVoteApi#mascotVoteGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MascotVoteApi;

public class MascotVoteApiExample {
    public static void main(String[] args) {
        MascotVoteApi apiInstance = new MascotVoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.mascotVoteGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling MascotVoteApi#mascotVoteGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MascotVoteApi *apiInstance = [[MascotVoteApi alloc] init];
String *userAgent = userAgent_example; //  (optional) (default to null)
String *targetYear = yyyy; //  (optional) (default to null)

// mascot_vote
[apiInstance mascotVoteGetWith:userAgent
    targetYear:targetYear
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.MascotVoteApi()
var opts = {
  'userAgent': userAgent_example, // {String} 
  'targetYear': yyyy // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.mascotVoteGet(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class mascotVoteGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new MascotVoteApi();
            var userAgent = userAgent_example;  // String |  (optional)  (default to null)
            var targetYear = yyyy;  // String |  (optional)  (default to null)

            try {
                // mascot_vote
                apiInstance.mascotVoteGet(userAgent, targetYear);
            } catch (Exception e) {
                Debug.Print("Exception when calling MascotVoteApi.mascotVoteGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MascotVoteApi();
$userAgent = userAgent_example; // String | 
$targetYear = yyyy; // String | 

try {
    $api_instance->mascotVoteGet($userAgent, $targetYear);
} catch (Exception $e) {
    echo 'Exception when calling MascotVoteApi->mascotVoteGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MascotVoteApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MascotVoteApi->new();
my $userAgent = userAgent_example; # String | 
my $targetYear = yyyy; # String | 

eval {
    $api_instance->mascotVoteGet(userAgent => $userAgent, targetYear => $targetYear);
};
if ($@) {
    warn "Exception when calling MascotVoteApi->mascotVoteGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MascotVoteApi()
userAgent = userAgent_example # String |  (optional) (default to null)
targetYear = yyyy # String |  (optional) (default to null)

try:
    # mascot_vote
    api_instance.mascot_vote_get(userAgent=userAgent, targetYear=targetYear)
except ApiException as e:
    print("Exception when calling MascotVoteApi->mascotVoteGet: %s\n" % e)
extern crate MascotVoteApi;

pub fn main() {
    let userAgent = userAgent_example; // String
    let targetYear = yyyy; // String

    let mut context = MascotVoteApi::Context::default();
    let result = client.mascotVoteGet(userAgent, targetYear, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Header parameters
Name Description
User-Agent
String
Query parameters
Name Description
target_year
String

Responses


mascotVoteIndexApiGet

mascot_vote/index_api


/mascot_vote/index_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/mascot_vote/index_api?target_year=yyyy"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MascotVoteApi;

import java.io.File;
import java.util.*;

public class MascotVoteApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        MascotVoteApi apiInstance = new MascotVoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.mascotVoteIndexApiGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling MascotVoteApi#mascotVoteIndexApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MascotVoteApi;

public class MascotVoteApiExample {
    public static void main(String[] args) {
        MascotVoteApi apiInstance = new MascotVoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.mascotVoteIndexApiGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling MascotVoteApi#mascotVoteIndexApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MascotVoteApi *apiInstance = [[MascotVoteApi alloc] init];
String *userAgent = userAgent_example; //  (optional) (default to null)
String *targetYear = yyyy; //  (optional) (default to null)

// mascot_vote/index_api
[apiInstance mascotVoteIndexApiGetWith:userAgent
    targetYear:targetYear
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.MascotVoteApi()
var opts = {
  'userAgent': userAgent_example, // {String} 
  'targetYear': yyyy // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.mascotVoteIndexApiGet(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class mascotVoteIndexApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new MascotVoteApi();
            var userAgent = userAgent_example;  // String |  (optional)  (default to null)
            var targetYear = yyyy;  // String |  (optional)  (default to null)

            try {
                // mascot_vote/index_api
                apiInstance.mascotVoteIndexApiGet(userAgent, targetYear);
            } catch (Exception e) {
                Debug.Print("Exception when calling MascotVoteApi.mascotVoteIndexApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MascotVoteApi();
$userAgent = userAgent_example; // String | 
$targetYear = yyyy; // String | 

try {
    $api_instance->mascotVoteIndexApiGet($userAgent, $targetYear);
} catch (Exception $e) {
    echo 'Exception when calling MascotVoteApi->mascotVoteIndexApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MascotVoteApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MascotVoteApi->new();
my $userAgent = userAgent_example; # String | 
my $targetYear = yyyy; # String | 

eval {
    $api_instance->mascotVoteIndexApiGet(userAgent => $userAgent, targetYear => $targetYear);
};
if ($@) {
    warn "Exception when calling MascotVoteApi->mascotVoteIndexApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MascotVoteApi()
userAgent = userAgent_example # String |  (optional) (default to null)
targetYear = yyyy # String |  (optional) (default to null)

try:
    # mascot_vote/index_api
    api_instance.mascot_vote_index_api_get(userAgent=userAgent, targetYear=targetYear)
except ApiException as e:
    print("Exception when calling MascotVoteApi->mascotVoteIndexApiGet: %s\n" % e)
extern crate MascotVoteApi;

pub fn main() {
    let userAgent = userAgent_example; // String
    let targetYear = yyyy; // String

    let mut context = MascotVoteApi::Context::default();
    let result = client.mascotVoteIndexApiGet(userAgent, targetYear, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Header parameters
Name Description
User-Agent
String
Query parameters
Name Description
target_year
String

Responses


MatchReward

matchRewardGet

match_reward


/match_reward

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/match_reward"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MatchRewardApi;

import java.io.File;
import java.util.*;

public class MatchRewardApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        MatchRewardApi apiInstance = new MatchRewardApi();

        try {
            apiInstance.matchRewardGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MatchRewardApi#matchRewardGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MatchRewardApi;

public class MatchRewardApiExample {
    public static void main(String[] args) {
        MatchRewardApi apiInstance = new MatchRewardApi();

        try {
            apiInstance.matchRewardGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MatchRewardApi#matchRewardGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MatchRewardApi *apiInstance = [[MatchRewardApi alloc] init];

// match_reward
[apiInstance matchRewardGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.MatchRewardApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.matchRewardGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class matchRewardGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new MatchRewardApi();

            try {
                // match_reward
                apiInstance.matchRewardGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling MatchRewardApi.matchRewardGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MatchRewardApi();

try {
    $api_instance->matchRewardGet();
} catch (Exception $e) {
    echo 'Exception when calling MatchRewardApi->matchRewardGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MatchRewardApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MatchRewardApi->new();

eval {
    $api_instance->matchRewardGet();
};
if ($@) {
    warn "Exception when calling MatchRewardApi->matchRewardGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MatchRewardApi()

try:
    # match_reward
    api_instance.match_reward_get()
except ApiException as e:
    print("Exception when calling MatchRewardApi->matchRewardGet: %s\n" % e)
extern crate MatchRewardApi;

pub fn main() {

    let mut context = MatchRewardApi::Context::default();
    let result = client.matchRewardGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


matchRewardIndexApiGet

match_reward/index_api


/match_reward/index_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/match_reward/index_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MatchRewardApi;

import java.io.File;
import java.util.*;

public class MatchRewardApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        MatchRewardApi apiInstance = new MatchRewardApi();

        try {
            apiInstance.matchRewardIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MatchRewardApi#matchRewardIndexApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MatchRewardApi;

public class MatchRewardApiExample {
    public static void main(String[] args) {
        MatchRewardApi apiInstance = new MatchRewardApi();

        try {
            apiInstance.matchRewardIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MatchRewardApi#matchRewardIndexApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MatchRewardApi *apiInstance = [[MatchRewardApi alloc] init];

// match_reward/index_api
[apiInstance matchRewardIndexApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.MatchRewardApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.matchRewardIndexApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class matchRewardIndexApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new MatchRewardApi();

            try {
                // match_reward/index_api
                apiInstance.matchRewardIndexApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling MatchRewardApi.matchRewardIndexApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MatchRewardApi();

try {
    $api_instance->matchRewardIndexApiGet();
} catch (Exception $e) {
    echo 'Exception when calling MatchRewardApi->matchRewardIndexApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MatchRewardApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MatchRewardApi->new();

eval {
    $api_instance->matchRewardIndexApiGet();
};
if ($@) {
    warn "Exception when calling MatchRewardApi->matchRewardIndexApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MatchRewardApi()

try:
    # match_reward/index_api
    api_instance.match_reward_index_api_get()
except ApiException as e:
    print("Exception when calling MatchRewardApi->matchRewardIndexApiGet: %s\n" % e)
extern crate MatchRewardApi;

pub fn main() {

    let mut context = MatchRewardApi::Context::default();
    let result = client.matchRewardIndexApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


Member

memberGet

member


/member

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/member"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MemberApi;

import java.io.File;
import java.util.*;

public class MemberApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        MemberApi apiInstance = new MemberApi();

        try {
            apiInstance.memberGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MemberApi#memberGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MemberApi;

public class MemberApiExample {
    public static void main(String[] args) {
        MemberApi apiInstance = new MemberApi();

        try {
            apiInstance.memberGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MemberApi#memberGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MemberApi *apiInstance = [[MemberApi alloc] init];

// member
[apiInstance memberGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.MemberApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.memberGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class memberGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new MemberApi();

            try {
                // member
                apiInstance.memberGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling MemberApi.memberGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MemberApi();

try {
    $api_instance->memberGet();
} catch (Exception $e) {
    echo 'Exception when calling MemberApi->memberGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MemberApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MemberApi->new();

eval {
    $api_instance->memberGet();
};
if ($@) {
    warn "Exception when calling MemberApi->memberGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MemberApi()

try:
    # member
    api_instance.member_get()
except ApiException as e:
    print("Exception when calling MemberApi->memberGet: %s\n" % e)
extern crate MemberApi;

pub fn main() {

    let mut context = MemberApi::Context::default();
    let result = client.memberGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


memberIndexApiGet

member/index_api


/member/index_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/member/index_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MemberApi;

import java.io.File;
import java.util.*;

public class MemberApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        MemberApi apiInstance = new MemberApi();

        try {
            apiInstance.memberIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MemberApi#memberIndexApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MemberApi;

public class MemberApiExample {
    public static void main(String[] args) {
        MemberApi apiInstance = new MemberApi();

        try {
            apiInstance.memberIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MemberApi#memberIndexApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MemberApi *apiInstance = [[MemberApi alloc] init];

// member/index_api
[apiInstance memberIndexApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.MemberApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.memberIndexApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class memberIndexApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new MemberApi();

            try {
                // member/index_api
                apiInstance.memberIndexApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling MemberApi.memberIndexApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MemberApi();

try {
    $api_instance->memberIndexApiGet();
} catch (Exception $e) {
    echo 'Exception when calling MemberApi->memberIndexApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MemberApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MemberApi->new();

eval {
    $api_instance->memberIndexApiGet();
};
if ($@) {
    warn "Exception when calling MemberApi->memberIndexApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MemberApi()

try:
    # member/index_api
    api_instance.member_index_api_get()
except ApiException as e:
    print("Exception when calling MemberApi->memberIndexApiGet: %s\n" % e)
extern crate MemberApi;

pub fn main() {

    let mut context = MemberApi::Context::default();
    let result = client.memberIndexApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


MemberAccountTransfer

memberAccountTransferGet

member_account_transfer


/member_account_transfer

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/member_account_transfer"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MemberAccountTransferApi;

import java.io.File;
import java.util.*;

public class MemberAccountTransferApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        MemberAccountTransferApi apiInstance = new MemberAccountTransferApi();

        try {
            apiInstance.memberAccountTransferGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MemberAccountTransferApi#memberAccountTransferGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MemberAccountTransferApi;

public class MemberAccountTransferApiExample {
    public static void main(String[] args) {
        MemberAccountTransferApi apiInstance = new MemberAccountTransferApi();

        try {
            apiInstance.memberAccountTransferGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MemberAccountTransferApi#memberAccountTransferGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MemberAccountTransferApi *apiInstance = [[MemberAccountTransferApi alloc] init];

// member_account_transfer
[apiInstance memberAccountTransferGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.MemberAccountTransferApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.memberAccountTransferGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class memberAccountTransferGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new MemberAccountTransferApi();

            try {
                // member_account_transfer
                apiInstance.memberAccountTransferGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling MemberAccountTransferApi.memberAccountTransferGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MemberAccountTransferApi();

try {
    $api_instance->memberAccountTransferGet();
} catch (Exception $e) {
    echo 'Exception when calling MemberAccountTransferApi->memberAccountTransferGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MemberAccountTransferApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MemberAccountTransferApi->new();

eval {
    $api_instance->memberAccountTransferGet();
};
if ($@) {
    warn "Exception when calling MemberAccountTransferApi->memberAccountTransferGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MemberAccountTransferApi()

try:
    # member_account_transfer
    api_instance.member_account_transfer_get()
except ApiException as e:
    print("Exception when calling MemberAccountTransferApi->memberAccountTransferGet: %s\n" % e)
extern crate MemberAccountTransferApi;

pub fn main() {

    let mut context = MemberAccountTransferApi::Context::default();
    let result = client.memberAccountTransferGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


memberAccountTransferIndexApiGet

member_account_transfer/index_api


/member_account_transfer/index_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/member_account_transfer/index_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MemberAccountTransferApi;

import java.io.File;
import java.util.*;

public class MemberAccountTransferApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        MemberAccountTransferApi apiInstance = new MemberAccountTransferApi();

        try {
            apiInstance.memberAccountTransferIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MemberAccountTransferApi#memberAccountTransferIndexApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MemberAccountTransferApi;

public class MemberAccountTransferApiExample {
    public static void main(String[] args) {
        MemberAccountTransferApi apiInstance = new MemberAccountTransferApi();

        try {
            apiInstance.memberAccountTransferIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MemberAccountTransferApi#memberAccountTransferIndexApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MemberAccountTransferApi *apiInstance = [[MemberAccountTransferApi alloc] init];

// member_account_transfer/index_api
[apiInstance memberAccountTransferIndexApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.MemberAccountTransferApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.memberAccountTransferIndexApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class memberAccountTransferIndexApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new MemberAccountTransferApi();

            try {
                // member_account_transfer/index_api
                apiInstance.memberAccountTransferIndexApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling MemberAccountTransferApi.memberAccountTransferIndexApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MemberAccountTransferApi();

try {
    $api_instance->memberAccountTransferIndexApiGet();
} catch (Exception $e) {
    echo 'Exception when calling MemberAccountTransferApi->memberAccountTransferIndexApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MemberAccountTransferApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MemberAccountTransferApi->new();

eval {
    $api_instance->memberAccountTransferIndexApiGet();
};
if ($@) {
    warn "Exception when calling MemberAccountTransferApi->memberAccountTransferIndexApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MemberAccountTransferApi()

try:
    # member_account_transfer/index_api
    api_instance.member_account_transfer_index_api_get()
except ApiException as e:
    print("Exception when calling MemberAccountTransferApi->memberAccountTransferIndexApiGet: %s\n" % e)
extern crate MemberAccountTransferApi;

pub fn main() {

    let mut context = MemberAccountTransferApi::Context::default();
    let result = client.memberAccountTransferIndexApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


memberAccountTransferNotesApiGet

member_account_transfer Copy 2


/member_account_transfer/notes_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/member_account_transfer/notes_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MemberAccountTransferApi;

import java.io.File;
import java.util.*;

public class MemberAccountTransferApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        MemberAccountTransferApi apiInstance = new MemberAccountTransferApi();

        try {
            apiInstance.memberAccountTransferNotesApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MemberAccountTransferApi#memberAccountTransferNotesApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MemberAccountTransferApi;

public class MemberAccountTransferApiExample {
    public static void main(String[] args) {
        MemberAccountTransferApi apiInstance = new MemberAccountTransferApi();

        try {
            apiInstance.memberAccountTransferNotesApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MemberAccountTransferApi#memberAccountTransferNotesApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MemberAccountTransferApi *apiInstance = [[MemberAccountTransferApi alloc] init];

// member_account_transfer Copy 2
[apiInstance memberAccountTransferNotesApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.MemberAccountTransferApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.memberAccountTransferNotesApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class memberAccountTransferNotesApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new MemberAccountTransferApi();

            try {
                // member_account_transfer Copy 2
                apiInstance.memberAccountTransferNotesApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling MemberAccountTransferApi.memberAccountTransferNotesApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MemberAccountTransferApi();

try {
    $api_instance->memberAccountTransferNotesApiGet();
} catch (Exception $e) {
    echo 'Exception when calling MemberAccountTransferApi->memberAccountTransferNotesApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MemberAccountTransferApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MemberAccountTransferApi->new();

eval {
    $api_instance->memberAccountTransferNotesApiGet();
};
if ($@) {
    warn "Exception when calling MemberAccountTransferApi->memberAccountTransferNotesApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MemberAccountTransferApi()

try:
    # member_account_transfer Copy 2
    api_instance.member_account_transfer_notes_api_get()
except ApiException as e:
    print("Exception when calling MemberAccountTransferApi->memberAccountTransferNotesApiGet: %s\n" % e)
extern crate MemberAccountTransferApi;

pub fn main() {

    let mut context = MemberAccountTransferApi::Context::default();
    let result = client.memberAccountTransferNotesApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


memberAccountTransferNotesGet

member_account_transfer


/member_account_transfer/notes

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/member_account_transfer/notes"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MemberAccountTransferApi;

import java.io.File;
import java.util.*;

public class MemberAccountTransferApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        MemberAccountTransferApi apiInstance = new MemberAccountTransferApi();

        try {
            apiInstance.memberAccountTransferNotesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MemberAccountTransferApi#memberAccountTransferNotesGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MemberAccountTransferApi;

public class MemberAccountTransferApiExample {
    public static void main(String[] args) {
        MemberAccountTransferApi apiInstance = new MemberAccountTransferApi();

        try {
            apiInstance.memberAccountTransferNotesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MemberAccountTransferApi#memberAccountTransferNotesGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MemberAccountTransferApi *apiInstance = [[MemberAccountTransferApi alloc] init];

// member_account_transfer
[apiInstance memberAccountTransferNotesGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.MemberAccountTransferApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.memberAccountTransferNotesGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class memberAccountTransferNotesGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new MemberAccountTransferApi();

            try {
                // member_account_transfer
                apiInstance.memberAccountTransferNotesGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling MemberAccountTransferApi.memberAccountTransferNotesGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MemberAccountTransferApi();

try {
    $api_instance->memberAccountTransferNotesGet();
} catch (Exception $e) {
    echo 'Exception when calling MemberAccountTransferApi->memberAccountTransferNotesGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MemberAccountTransferApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MemberAccountTransferApi->new();

eval {
    $api_instance->memberAccountTransferNotesGet();
};
if ($@) {
    warn "Exception when calling MemberAccountTransferApi->memberAccountTransferNotesGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MemberAccountTransferApi()

try:
    # member_account_transfer
    api_instance.member_account_transfer_notes_get()
except ApiException as e:
    print("Exception when calling MemberAccountTransferApi->memberAccountTransferNotesGet: %s\n" % e)
extern crate MemberAccountTransferApi;

pub fn main() {

    let mut context = MemberAccountTransferApi::Context::default();
    let result = client.memberAccountTransferNotesGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


MemberRegister

memberRegisterGet

member_register


/member_register

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/member_register"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MemberRegisterApi;

import java.io.File;
import java.util.*;

public class MemberRegisterApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        MemberRegisterApi apiInstance = new MemberRegisterApi();

        try {
            apiInstance.memberRegisterGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MemberRegisterApi#memberRegisterGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MemberRegisterApi;

public class MemberRegisterApiExample {
    public static void main(String[] args) {
        MemberRegisterApi apiInstance = new MemberRegisterApi();

        try {
            apiInstance.memberRegisterGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MemberRegisterApi#memberRegisterGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MemberRegisterApi *apiInstance = [[MemberRegisterApi alloc] init];

// member_register
[apiInstance memberRegisterGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.MemberRegisterApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.memberRegisterGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class memberRegisterGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new MemberRegisterApi();

            try {
                // member_register
                apiInstance.memberRegisterGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling MemberRegisterApi.memberRegisterGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MemberRegisterApi();

try {
    $api_instance->memberRegisterGet();
} catch (Exception $e) {
    echo 'Exception when calling MemberRegisterApi->memberRegisterGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MemberRegisterApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MemberRegisterApi->new();

eval {
    $api_instance->memberRegisterGet();
};
if ($@) {
    warn "Exception when calling MemberRegisterApi->memberRegisterGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MemberRegisterApi()

try:
    # member_register
    api_instance.member_register_get()
except ApiException as e:
    print("Exception when calling MemberRegisterApi->memberRegisterGet: %s\n" % e)
extern crate MemberRegisterApi;

pub fn main() {

    let mut context = MemberRegisterApi::Context::default();
    let result = client.memberRegisterGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


memberRegisterIndexApiGet

member_register/index_api


/member_register/index_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/member_register/index_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MemberRegisterApi;

import java.io.File;
import java.util.*;

public class MemberRegisterApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        MemberRegisterApi apiInstance = new MemberRegisterApi();

        try {
            apiInstance.memberRegisterIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MemberRegisterApi#memberRegisterIndexApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MemberRegisterApi;

public class MemberRegisterApiExample {
    public static void main(String[] args) {
        MemberRegisterApi apiInstance = new MemberRegisterApi();

        try {
            apiInstance.memberRegisterIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MemberRegisterApi#memberRegisterIndexApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MemberRegisterApi *apiInstance = [[MemberRegisterApi alloc] init];

// member_register/index_api
[apiInstance memberRegisterIndexApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.MemberRegisterApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.memberRegisterIndexApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class memberRegisterIndexApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new MemberRegisterApi();

            try {
                // member_register/index_api
                apiInstance.memberRegisterIndexApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling MemberRegisterApi.memberRegisterIndexApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MemberRegisterApi();

try {
    $api_instance->memberRegisterIndexApiGet();
} catch (Exception $e) {
    echo 'Exception when calling MemberRegisterApi->memberRegisterIndexApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MemberRegisterApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MemberRegisterApi->new();

eval {
    $api_instance->memberRegisterIndexApiGet();
};
if ($@) {
    warn "Exception when calling MemberRegisterApi->memberRegisterIndexApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MemberRegisterApi()

try:
    # member_register/index_api
    api_instance.member_register_index_api_get()
except ApiException as e:
    print("Exception when calling MemberRegisterApi->memberRegisterIndexApiGet: %s\n" % e)
extern crate MemberRegisterApi;

pub fn main() {

    let mut context = MemberRegisterApi::Context::default();
    let result = client.memberRegisterIndexApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


memberRegisterNotesApiGet

member_register/notes_api


/member_register/notes_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/member_register/notes_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MemberRegisterApi;

import java.io.File;
import java.util.*;

public class MemberRegisterApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        MemberRegisterApi apiInstance = new MemberRegisterApi();

        try {
            apiInstance.memberRegisterNotesApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MemberRegisterApi#memberRegisterNotesApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MemberRegisterApi;

public class MemberRegisterApiExample {
    public static void main(String[] args) {
        MemberRegisterApi apiInstance = new MemberRegisterApi();

        try {
            apiInstance.memberRegisterNotesApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MemberRegisterApi#memberRegisterNotesApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MemberRegisterApi *apiInstance = [[MemberRegisterApi alloc] init];

// member_register/notes_api
[apiInstance memberRegisterNotesApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.MemberRegisterApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.memberRegisterNotesApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class memberRegisterNotesApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new MemberRegisterApi();

            try {
                // member_register/notes_api
                apiInstance.memberRegisterNotesApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling MemberRegisterApi.memberRegisterNotesApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MemberRegisterApi();

try {
    $api_instance->memberRegisterNotesApiGet();
} catch (Exception $e) {
    echo 'Exception when calling MemberRegisterApi->memberRegisterNotesApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MemberRegisterApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MemberRegisterApi->new();

eval {
    $api_instance->memberRegisterNotesApiGet();
};
if ($@) {
    warn "Exception when calling MemberRegisterApi->memberRegisterNotesApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MemberRegisterApi()

try:
    # member_register/notes_api
    api_instance.member_register_notes_api_get()
except ApiException as e:
    print("Exception when calling MemberRegisterApi->memberRegisterNotesApiGet: %s\n" % e)
extern crate MemberRegisterApi;

pub fn main() {

    let mut context = MemberRegisterApi::Context::default();
    let result = client.memberRegisterNotesApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


memberRegisterNotesGet

member_register/notes


/member_register/notes

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/member_register/notes"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MemberRegisterApi;

import java.io.File;
import java.util.*;

public class MemberRegisterApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        MemberRegisterApi apiInstance = new MemberRegisterApi();

        try {
            apiInstance.memberRegisterNotesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MemberRegisterApi#memberRegisterNotesGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MemberRegisterApi;

public class MemberRegisterApiExample {
    public static void main(String[] args) {
        MemberRegisterApi apiInstance = new MemberRegisterApi();

        try {
            apiInstance.memberRegisterNotesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MemberRegisterApi#memberRegisterNotesGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MemberRegisterApi *apiInstance = [[MemberRegisterApi alloc] init];

// member_register/notes
[apiInstance memberRegisterNotesGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.MemberRegisterApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.memberRegisterNotesGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class memberRegisterNotesGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new MemberRegisterApi();

            try {
                // member_register/notes
                apiInstance.memberRegisterNotesGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling MemberRegisterApi.memberRegisterNotesGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MemberRegisterApi();

try {
    $api_instance->memberRegisterNotesGet();
} catch (Exception $e) {
    echo 'Exception when calling MemberRegisterApi->memberRegisterNotesGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MemberRegisterApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MemberRegisterApi->new();

eval {
    $api_instance->memberRegisterNotesGet();
};
if ($@) {
    warn "Exception when calling MemberRegisterApi->memberRegisterNotesGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MemberRegisterApi()

try:
    # member_register/notes
    api_instance.member_register_notes_get()
except ApiException as e:
    print("Exception when calling MemberRegisterApi->memberRegisterNotesGet: %s\n" % e)
extern crate MemberRegisterApi;

pub fn main() {

    let mut context = MemberRegisterApi::Context::default();
    let result = client.memberRegisterNotesGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


Menu

menuGet

menu


/menu

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/menu"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MenuApi;

import java.io.File;
import java.util.*;

public class MenuApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        MenuApi apiInstance = new MenuApi();

        try {
            apiInstance.menuGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuApi#menuGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MenuApi;

public class MenuApiExample {
    public static void main(String[] args) {
        MenuApi apiInstance = new MenuApi();

        try {
            apiInstance.menuGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuApi#menuGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MenuApi *apiInstance = [[MenuApi alloc] init];

// menu
[apiInstance menuGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.MenuApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.menuGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class menuGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new MenuApi();

            try {
                // menu
                apiInstance.menuGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling MenuApi.menuGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MenuApi();

try {
    $api_instance->menuGet();
} catch (Exception $e) {
    echo 'Exception when calling MenuApi->menuGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MenuApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MenuApi->new();

eval {
    $api_instance->menuGet();
};
if ($@) {
    warn "Exception when calling MenuApi->menuGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MenuApi()

try:
    # menu
    api_instance.menu_get()
except ApiException as e:
    print("Exception when calling MenuApi->menuGet: %s\n" % e)
extern crate MenuApi;

pub fn main() {

    let mut context = MenuApi::Context::default();
    let result = client.menuGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


menuIndexApiGet

menu/index_api


/menu/index_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/menu/index_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MenuApi;

import java.io.File;
import java.util.*;

public class MenuApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        MenuApi apiInstance = new MenuApi();

        try {
            apiInstance.menuIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuApi#menuIndexApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MenuApi;

public class MenuApiExample {
    public static void main(String[] args) {
        MenuApi apiInstance = new MenuApi();

        try {
            apiInstance.menuIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuApi#menuIndexApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MenuApi *apiInstance = [[MenuApi alloc] init];

// menu/index_api
[apiInstance menuIndexApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.MenuApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.menuIndexApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class menuIndexApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new MenuApi();

            try {
                // menu/index_api
                apiInstance.menuIndexApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling MenuApi.menuIndexApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MenuApi();

try {
    $api_instance->menuIndexApiGet();
} catch (Exception $e) {
    echo 'Exception when calling MenuApi->menuIndexApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MenuApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MenuApi->new();

eval {
    $api_instance->menuIndexApiGet();
};
if ($@) {
    warn "Exception when calling MenuApi->menuIndexApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MenuApi()

try:
    # menu/index_api
    api_instance.menu_index_api_get()
except ApiException as e:
    print("Exception when calling MenuApi->menuIndexApiGet: %s\n" % e)
extern crate MenuApi;

pub fn main() {

    let mut context = MenuApi::Context::default();
    let result = client.menuIndexApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


Minimail

minimailGet

minimail


/minimail

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/minimail"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MinimailApi;

import java.io.File;
import java.util.*;

public class MinimailApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        MinimailApi apiInstance = new MinimailApi();

        try {
            apiInstance.minimailGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MinimailApi#minimailGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MinimailApi;

public class MinimailApiExample {
    public static void main(String[] args) {
        MinimailApi apiInstance = new MinimailApi();

        try {
            apiInstance.minimailGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MinimailApi#minimailGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MinimailApi *apiInstance = [[MinimailApi alloc] init];

// minimail
[apiInstance minimailGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.MinimailApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.minimailGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class minimailGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new MinimailApi();

            try {
                // minimail
                apiInstance.minimailGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling MinimailApi.minimailGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MinimailApi();

try {
    $api_instance->minimailGet();
} catch (Exception $e) {
    echo 'Exception when calling MinimailApi->minimailGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MinimailApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MinimailApi->new();

eval {
    $api_instance->minimailGet();
};
if ($@) {
    warn "Exception when calling MinimailApi->minimailGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MinimailApi()

try:
    # minimail
    api_instance.minimail_get()
except ApiException as e:
    print("Exception when calling MinimailApi->minimailGet: %s\n" % e)
extern crate MinimailApi;

pub fn main() {

    let mut context = MinimailApi::Context::default();
    let result = client.minimailGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


minimailIndexApiGet

minimail/index_api


/minimail/index_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/minimail/index_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MinimailApi;

import java.io.File;
import java.util.*;

public class MinimailApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        MinimailApi apiInstance = new MinimailApi();

        try {
            apiInstance.minimailIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MinimailApi#minimailIndexApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MinimailApi;

public class MinimailApiExample {
    public static void main(String[] args) {
        MinimailApi apiInstance = new MinimailApi();

        try {
            apiInstance.minimailIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MinimailApi#minimailIndexApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MinimailApi *apiInstance = [[MinimailApi alloc] init];

// minimail/index_api
[apiInstance minimailIndexApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.MinimailApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.minimailIndexApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class minimailIndexApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new MinimailApi();

            try {
                // minimail/index_api
                apiInstance.minimailIndexApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling MinimailApi.minimailIndexApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MinimailApi();

try {
    $api_instance->minimailIndexApiGet();
} catch (Exception $e) {
    echo 'Exception when calling MinimailApi->minimailIndexApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MinimailApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MinimailApi->new();

eval {
    $api_instance->minimailIndexApiGet();
};
if ($@) {
    warn "Exception when calling MinimailApi->minimailIndexApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MinimailApi()

try:
    # minimail/index_api
    api_instance.minimail_index_api_get()
except ApiException as e:
    print("Exception when calling MinimailApi->minimailIndexApiGet: %s\n" % e)
extern crate MinimailApi;

pub fn main() {

    let mut context = MinimailApi::Context::default();
    let result = client.minimailIndexApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


Mission

missionCompleteApiGet

mission/complete_api


/mission/complete_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/mission/complete_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MissionApi;

import java.io.File;
import java.util.*;

public class MissionApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        MissionApi apiInstance = new MissionApi();

        try {
            apiInstance.missionCompleteApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MissionApi#missionCompleteApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MissionApi;

public class MissionApiExample {
    public static void main(String[] args) {
        MissionApi apiInstance = new MissionApi();

        try {
            apiInstance.missionCompleteApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MissionApi#missionCompleteApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MissionApi *apiInstance = [[MissionApi alloc] init];

// mission/complete_api
[apiInstance missionCompleteApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.MissionApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.missionCompleteApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class missionCompleteApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new MissionApi();

            try {
                // mission/complete_api
                apiInstance.missionCompleteApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling MissionApi.missionCompleteApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MissionApi();

try {
    $api_instance->missionCompleteApiGet();
} catch (Exception $e) {
    echo 'Exception when calling MissionApi->missionCompleteApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MissionApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MissionApi->new();

eval {
    $api_instance->missionCompleteApiGet();
};
if ($@) {
    warn "Exception when calling MissionApi->missionCompleteApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MissionApi()

try:
    # mission/complete_api
    api_instance.mission_complete_api_get()
except ApiException as e:
    print("Exception when calling MissionApi->missionCompleteApiGet: %s\n" % e)
extern crate MissionApi;

pub fn main() {

    let mut context = MissionApi::Context::default();
    let result = client.missionCompleteApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


missionCompleteGet

mission/complete


/mission/complete

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/mission/complete"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MissionApi;

import java.io.File;
import java.util.*;

public class MissionApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        MissionApi apiInstance = new MissionApi();

        try {
            apiInstance.missionCompleteGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MissionApi#missionCompleteGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MissionApi;

public class MissionApiExample {
    public static void main(String[] args) {
        MissionApi apiInstance = new MissionApi();

        try {
            apiInstance.missionCompleteGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MissionApi#missionCompleteGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MissionApi *apiInstance = [[MissionApi alloc] init];

// mission/complete
[apiInstance missionCompleteGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.MissionApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.missionCompleteGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class missionCompleteGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new MissionApi();

            try {
                // mission/complete
                apiInstance.missionCompleteGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling MissionApi.missionCompleteGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MissionApi();

try {
    $api_instance->missionCompleteGet();
} catch (Exception $e) {
    echo 'Exception when calling MissionApi->missionCompleteGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MissionApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MissionApi->new();

eval {
    $api_instance->missionCompleteGet();
};
if ($@) {
    warn "Exception when calling MissionApi->missionCompleteGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MissionApi()

try:
    # mission/complete
    api_instance.mission_complete_get()
except ApiException as e:
    print("Exception when calling MissionApi->missionCompleteGet: %s\n" % e)
extern crate MissionApi;

pub fn main() {

    let mut context = MissionApi::Context::default();
    let result = client.missionCompleteGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


missionGet

mission


/mission

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/mission"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MissionApi;

import java.io.File;
import java.util.*;

public class MissionApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        MissionApi apiInstance = new MissionApi();

        try {
            apiInstance.missionGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MissionApi#missionGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MissionApi;

public class MissionApiExample {
    public static void main(String[] args) {
        MissionApi apiInstance = new MissionApi();

        try {
            apiInstance.missionGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MissionApi#missionGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MissionApi *apiInstance = [[MissionApi alloc] init];

// mission
[apiInstance missionGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.MissionApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.missionGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class missionGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new MissionApi();

            try {
                // mission
                apiInstance.missionGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling MissionApi.missionGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MissionApi();

try {
    $api_instance->missionGet();
} catch (Exception $e) {
    echo 'Exception when calling MissionApi->missionGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MissionApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MissionApi->new();

eval {
    $api_instance->missionGet();
};
if ($@) {
    warn "Exception when calling MissionApi->missionGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MissionApi()

try:
    # mission
    api_instance.mission_get()
except ApiException as e:
    print("Exception when calling MissionApi->missionGet: %s\n" % e)
extern crate MissionApi;

pub fn main() {

    let mut context = MissionApi::Context::default();
    let result = client.missionGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


missionIndexApiGet

mission/index_api


/mission/index_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/mission/index_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MissionApi;

import java.io.File;
import java.util.*;

public class MissionApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        MissionApi apiInstance = new MissionApi();

        try {
            apiInstance.missionIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MissionApi#missionIndexApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MissionApi;

public class MissionApiExample {
    public static void main(String[] args) {
        MissionApi apiInstance = new MissionApi();

        try {
            apiInstance.missionIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MissionApi#missionIndexApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MissionApi *apiInstance = [[MissionApi alloc] init];

// mission/index_api
[apiInstance missionIndexApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.MissionApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.missionIndexApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class missionIndexApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new MissionApi();

            try {
                // mission/index_api
                apiInstance.missionIndexApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling MissionApi.missionIndexApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MissionApi();

try {
    $api_instance->missionIndexApiGet();
} catch (Exception $e) {
    echo 'Exception when calling MissionApi->missionIndexApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MissionApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MissionApi->new();

eval {
    $api_instance->missionIndexApiGet();
};
if ($@) {
    warn "Exception when calling MissionApi->missionIndexApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MissionApi()

try:
    # mission/index_api
    api_instance.mission_index_api_get()
except ApiException as e:
    print("Exception when calling MissionApi->missionIndexApiGet: %s\n" % e)
extern crate MissionApi;

pub fn main() {

    let mut context = MissionApi::Context::default();
    let result = client.missionIndexApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


missionMonthlyApiGet

mission/monthly_api


/mission/monthly_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/mission/monthly_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MissionApi;

import java.io.File;
import java.util.*;

public class MissionApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        MissionApi apiInstance = new MissionApi();

        try {
            apiInstance.missionMonthlyApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MissionApi#missionMonthlyApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MissionApi;

public class MissionApiExample {
    public static void main(String[] args) {
        MissionApi apiInstance = new MissionApi();

        try {
            apiInstance.missionMonthlyApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MissionApi#missionMonthlyApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MissionApi *apiInstance = [[MissionApi alloc] init];

// mission/monthly_api
[apiInstance missionMonthlyApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.MissionApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.missionMonthlyApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class missionMonthlyApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new MissionApi();

            try {
                // mission/monthly_api
                apiInstance.missionMonthlyApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling MissionApi.missionMonthlyApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MissionApi();

try {
    $api_instance->missionMonthlyApiGet();
} catch (Exception $e) {
    echo 'Exception when calling MissionApi->missionMonthlyApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MissionApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MissionApi->new();

eval {
    $api_instance->missionMonthlyApiGet();
};
if ($@) {
    warn "Exception when calling MissionApi->missionMonthlyApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MissionApi()

try:
    # mission/monthly_api
    api_instance.mission_monthly_api_get()
except ApiException as e:
    print("Exception when calling MissionApi->missionMonthlyApiGet: %s\n" % e)
extern crate MissionApi;

pub fn main() {

    let mut context = MissionApi::Context::default();
    let result = client.missionMonthlyApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


missionMonthlyGet

mission/monthly


/mission/monthly

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/mission/monthly"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MissionApi;

import java.io.File;
import java.util.*;

public class MissionApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        MissionApi apiInstance = new MissionApi();

        try {
            apiInstance.missionMonthlyGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MissionApi#missionMonthlyGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MissionApi;

public class MissionApiExample {
    public static void main(String[] args) {
        MissionApi apiInstance = new MissionApi();

        try {
            apiInstance.missionMonthlyGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MissionApi#missionMonthlyGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MissionApi *apiInstance = [[MissionApi alloc] init];

// mission/monthly
[apiInstance missionMonthlyGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.MissionApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.missionMonthlyGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class missionMonthlyGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new MissionApi();

            try {
                // mission/monthly
                apiInstance.missionMonthlyGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling MissionApi.missionMonthlyGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MissionApi();

try {
    $api_instance->missionMonthlyGet();
} catch (Exception $e) {
    echo 'Exception when calling MissionApi->missionMonthlyGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MissionApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MissionApi->new();

eval {
    $api_instance->missionMonthlyGet();
};
if ($@) {
    warn "Exception when calling MissionApi->missionMonthlyGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MissionApi()

try:
    # mission/monthly
    api_instance.mission_monthly_get()
except ApiException as e:
    print("Exception when calling MissionApi->missionMonthlyGet: %s\n" % e)
extern crate MissionApi;

pub fn main() {

    let mut context = MissionApi::Context::default();
    let result = client.missionMonthlyGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


missionSeasonApiGet

mission/season_api


/mission/season_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/mission/season_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MissionApi;

import java.io.File;
import java.util.*;

public class MissionApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        MissionApi apiInstance = new MissionApi();

        try {
            apiInstance.missionSeasonApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MissionApi#missionSeasonApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MissionApi;

public class MissionApiExample {
    public static void main(String[] args) {
        MissionApi apiInstance = new MissionApi();

        try {
            apiInstance.missionSeasonApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MissionApi#missionSeasonApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MissionApi *apiInstance = [[MissionApi alloc] init];

// mission/season_api
[apiInstance missionSeasonApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.MissionApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.missionSeasonApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class missionSeasonApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new MissionApi();

            try {
                // mission/season_api
                apiInstance.missionSeasonApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling MissionApi.missionSeasonApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MissionApi();

try {
    $api_instance->missionSeasonApiGet();
} catch (Exception $e) {
    echo 'Exception when calling MissionApi->missionSeasonApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MissionApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MissionApi->new();

eval {
    $api_instance->missionSeasonApiGet();
};
if ($@) {
    warn "Exception when calling MissionApi->missionSeasonApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MissionApi()

try:
    # mission/season_api
    api_instance.mission_season_api_get()
except ApiException as e:
    print("Exception when calling MissionApi->missionSeasonApiGet: %s\n" % e)
extern crate MissionApi;

pub fn main() {

    let mut context = MissionApi::Context::default();
    let result = client.missionSeasonApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


missionSeasonGet

mission/season


/mission/season

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/mission/season"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MissionApi;

import java.io.File;
import java.util.*;

public class MissionApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        MissionApi apiInstance = new MissionApi();

        try {
            apiInstance.missionSeasonGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MissionApi#missionSeasonGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MissionApi;

public class MissionApiExample {
    public static void main(String[] args) {
        MissionApi apiInstance = new MissionApi();

        try {
            apiInstance.missionSeasonGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling MissionApi#missionSeasonGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MissionApi *apiInstance = [[MissionApi alloc] init];

// mission/season
[apiInstance missionSeasonGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.MissionApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.missionSeasonGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class missionSeasonGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new MissionApi();

            try {
                // mission/season
                apiInstance.missionSeasonGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling MissionApi.missionSeasonGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MissionApi();

try {
    $api_instance->missionSeasonGet();
} catch (Exception $e) {
    echo 'Exception when calling MissionApi->missionSeasonGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MissionApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MissionApi->new();

eval {
    $api_instance->missionSeasonGet();
};
if ($@) {
    warn "Exception when calling MissionApi->missionSeasonGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MissionApi()

try:
    # mission/season
    api_instance.mission_season_get()
except ApiException as e:
    print("Exception when calling MissionApi->missionSeasonGet: %s\n" % e)
extern crate MissionApi;

pub fn main() {

    let mut context = MissionApi::Context::default();
    let result = client.missionSeasonGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


Mypage

userMypageApiUidGet

user/mypage_api/:uid


/user/mypage_api/$uid

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/user/mypage_api/$uid"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MypageApi;

import java.io.File;
import java.util.*;

public class MypageApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        MypageApi apiInstance = new MypageApi();

        try {
            Object result = apiInstance.userMypageApiUidGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MypageApi#userMypageApiUidGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MypageApi;

public class MypageApiExample {
    public static void main(String[] args) {
        MypageApi apiInstance = new MypageApi();

        try {
            Object result = apiInstance.userMypageApiUidGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MypageApi#userMypageApiUidGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MypageApi *apiInstance = [[MypageApi alloc] init];

// user/mypage_api/:uid
[apiInstance userMypageApiUidGetWithCompletionHandler: 
              ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.MypageApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.userMypageApiUidGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class userMypageApiUidGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new MypageApi();

            try {
                // user/mypage_api/:uid
                Object result = apiInstance.userMypageApiUidGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MypageApi.userMypageApiUidGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MypageApi();

try {
    $result = $api_instance->userMypageApiUidGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MypageApi->userMypageApiUidGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MypageApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MypageApi->new();

eval {
    my $result = $api_instance->userMypageApiUidGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MypageApi->userMypageApiUidGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MypageApi()

try:
    # user/mypage_api/:uid
    api_response = api_instance.user_mypage_api_uid_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MypageApi->userMypageApiUidGet: %s\n" % e)
extern crate MypageApi;

pub fn main() {

    let mut context = MypageApi::Context::default();
    let result = client.userMypageApiUidGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Date String
ContentMinusType String
TransferMinusEncoding String
Connection String
Server String
XMinusPoweredMinusBy BigDecimal
Expires String
CacheMinusControl String
Pragma String

userMypageUidGet

user/mypage/:uid


/user/mypage/{uid}

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/user/mypage/{uid}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MypageApi;

import java.io.File;
import java.util.*;

public class MypageApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        MypageApi apiInstance = new MypageApi();
        String uid = uid_example; // String | 

        try {
            Object result = apiInstance.userMypageUidGet(uid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MypageApi#userMypageUidGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MypageApi;

public class MypageApiExample {
    public static void main(String[] args) {
        MypageApi apiInstance = new MypageApi();
        String uid = uid_example; // String | 

        try {
            Object result = apiInstance.userMypageUidGet(uid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MypageApi#userMypageUidGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
MypageApi *apiInstance = [[MypageApi alloc] init];
String *uid = uid_example; //  (default to null)

// user/mypage/:uid
[apiInstance userMypageUidGetWith:uid
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.MypageApi()
var uid = uid_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.userMypageUidGet(uid, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class userMypageUidGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new MypageApi();
            var uid = uid_example;  // String |  (default to null)

            try {
                // user/mypage/:uid
                Object result = apiInstance.userMypageUidGet(uid);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MypageApi.userMypageUidGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MypageApi();
$uid = uid_example; // String | 

try {
    $result = $api_instance->userMypageUidGet($uid);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MypageApi->userMypageUidGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MypageApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MypageApi->new();
my $uid = uid_example; # String | 

eval {
    my $result = $api_instance->userMypageUidGet(uid => $uid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MypageApi->userMypageUidGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.MypageApi()
uid = uid_example # String |  (default to null)

try:
    # user/mypage/:uid
    api_response = api_instance.user_mypage_uid_get(uid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MypageApi->userMypageUidGet: %s\n" % e)
extern crate MypageApi;

pub fn main() {
    let uid = uid_example; // String

    let mut context = MypageApi::Context::default();
    let result = client.userMypageUidGet(uid, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
uid*
String
Required

Responses

Name Type Format Description
Date String
ContentMinusType String
TransferMinusEncoding String
Connection String
Server String
XMinusPoweredMinusBy BigDecimal
Expires String
CacheMinusControl String
Pragma String

Page

pageIndexApiPageNameGet

page/index_api/:page_name


/page/index_api/{page_name}

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/page/index_api/{page_name}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PageApi;

import java.io.File;
import java.util.*;

public class PageApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        PageApi apiInstance = new PageApi();
        String pageName = pageName_example; // String | 

        try {
            Object result = apiInstance.pageIndexApiPageNameGet(pageName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PageApi#pageIndexApiPageNameGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.PageApi;

public class PageApiExample {
    public static void main(String[] args) {
        PageApi apiInstance = new PageApi();
        String pageName = pageName_example; // String | 

        try {
            Object result = apiInstance.pageIndexApiPageNameGet(pageName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PageApi#pageIndexApiPageNameGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
PageApi *apiInstance = [[PageApi alloc] init];
String *pageName = pageName_example; //  (default to null)

// page/index_api/:page_name
[apiInstance pageIndexApiPageNameGetWith:pageName
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.PageApi()
var pageName = pageName_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.pageIndexApiPageNameGet(pageName, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class pageIndexApiPageNameGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new PageApi();
            var pageName = pageName_example;  // String |  (default to null)

            try {
                // page/index_api/:page_name
                Object result = apiInstance.pageIndexApiPageNameGet(pageName);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PageApi.pageIndexApiPageNameGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PageApi();
$pageName = pageName_example; // String | 

try {
    $result = $api_instance->pageIndexApiPageNameGet($pageName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PageApi->pageIndexApiPageNameGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PageApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PageApi->new();
my $pageName = pageName_example; # String | 

eval {
    my $result = $api_instance->pageIndexApiPageNameGet(pageName => $pageName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PageApi->pageIndexApiPageNameGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.PageApi()
pageName = pageName_example # String |  (default to null)

try:
    # page/index_api/:page_name
    api_response = api_instance.page_index_api_page_name_get(pageName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PageApi->pageIndexApiPageNameGet: %s\n" % e)
extern crate PageApi;

pub fn main() {
    let pageName = pageName_example; // String

    let mut context = PageApi::Context::default();
    let result = client.pageIndexApiPageNameGet(pageName, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
page_name*
String
Required

Responses

Name Type Format Description
Date String
ContentMinusType String
TransferMinusEncoding String
Connection String
Server String
XMinusPoweredMinusBy BigDecimal
Expires String
CacheMinusControl String
Pragma String

pagePageNameGet

page/:page_name


/page/{page_name}

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/page/{page_name}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PageApi;

import java.io.File;
import java.util.*;

public class PageApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        PageApi apiInstance = new PageApi();
        String pageName = pageName_example; // String | 

        try {
            Object result = apiInstance.pagePageNameGet(pageName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PageApi#pagePageNameGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.PageApi;

public class PageApiExample {
    public static void main(String[] args) {
        PageApi apiInstance = new PageApi();
        String pageName = pageName_example; // String | 

        try {
            Object result = apiInstance.pagePageNameGet(pageName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PageApi#pagePageNameGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
PageApi *apiInstance = [[PageApi alloc] init];
String *pageName = pageName_example; //  (default to null)

// page/:page_name
[apiInstance pagePageNameGetWith:pageName
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.PageApi()
var pageName = pageName_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.pagePageNameGet(pageName, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class pagePageNameGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new PageApi();
            var pageName = pageName_example;  // String |  (default to null)

            try {
                // page/:page_name
                Object result = apiInstance.pagePageNameGet(pageName);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PageApi.pagePageNameGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PageApi();
$pageName = pageName_example; // String | 

try {
    $result = $api_instance->pagePageNameGet($pageName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PageApi->pagePageNameGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PageApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PageApi->new();
my $pageName = pageName_example; # String | 

eval {
    my $result = $api_instance->pagePageNameGet(pageName => $pageName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PageApi->pagePageNameGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.PageApi()
pageName = pageName_example # String |  (default to null)

try:
    # page/:page_name
    api_response = api_instance.page_page_name_get(pageName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PageApi->pagePageNameGet: %s\n" % e)
extern crate PageApi;

pub fn main() {
    let pageName = pageName_example; // String

    let mut context = PageApi::Context::default();
    let result = client.pagePageNameGet(pageName, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
page_name*
String
Required

Responses

Name Type Format Description
Date String
ContentMinusType String
TransferMinusEncoding String
Connection String
Server String
XMinusPoweredMinusBy BigDecimal
Expires String
CacheMinusControl String
Pragma String

Present

presentGet

present


/present

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/present?page=1"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PresentApi;

import java.io.File;
import java.util.*;

public class PresentApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        PresentApi apiInstance = new PresentApi();
        Integer page = 1; // Integer | 1ページ目

        try {
            apiInstance.presentGet(page);
        } catch (ApiException e) {
            System.err.println("Exception when calling PresentApi#presentGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.PresentApi;

public class PresentApiExample {
    public static void main(String[] args) {
        PresentApi apiInstance = new PresentApi();
        Integer page = 1; // Integer | 1ページ目

        try {
            apiInstance.presentGet(page);
        } catch (ApiException e) {
            System.err.println("Exception when calling PresentApi#presentGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
PresentApi *apiInstance = [[PresentApi alloc] init];
Integer *page = 1; // 1ページ目 (optional) (default to null)

// present
[apiInstance presentGetWith:page
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.PresentApi()
var opts = {
  'page': 1 // {Integer} 1ページ目
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.presentGet(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class presentGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new PresentApi();
            var page = 1;  // Integer | 1ページ目 (optional)  (default to null)

            try {
                // present
                apiInstance.presentGet(page);
            } catch (Exception e) {
                Debug.Print("Exception when calling PresentApi.presentGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PresentApi();
$page = 1; // Integer | 1ページ目

try {
    $api_instance->presentGet($page);
} catch (Exception $e) {
    echo 'Exception when calling PresentApi->presentGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PresentApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PresentApi->new();
my $page = 1; # Integer | 1ページ目

eval {
    $api_instance->presentGet(page => $page);
};
if ($@) {
    warn "Exception when calling PresentApi->presentGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.PresentApi()
page = 1 # Integer | 1ページ目 (optional) (default to null)

try:
    # present
    api_instance.present_get(page=page)
except ApiException as e:
    print("Exception when calling PresentApi->presentGet: %s\n" % e)
extern crate PresentApi;

pub fn main() {
    let page = 1; // Integer

    let mut context = PresentApi::Context::default();
    let result = client.presentGet(page, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
page
Integer
1ページ目

Responses


presentIndexApiGet

present/index_api


/present/index_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/present/index_api?page=1"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PresentApi;

import java.io.File;
import java.util.*;

public class PresentApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        PresentApi apiInstance = new PresentApi();
        Integer page = 1; // Integer | 1ページ目

        try {
            apiInstance.presentIndexApiGet(page);
        } catch (ApiException e) {
            System.err.println("Exception when calling PresentApi#presentIndexApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.PresentApi;

public class PresentApiExample {
    public static void main(String[] args) {
        PresentApi apiInstance = new PresentApi();
        Integer page = 1; // Integer | 1ページ目

        try {
            apiInstance.presentIndexApiGet(page);
        } catch (ApiException e) {
            System.err.println("Exception when calling PresentApi#presentIndexApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
PresentApi *apiInstance = [[PresentApi alloc] init];
Integer *page = 1; // 1ページ目 (optional) (default to null)

// present/index_api
[apiInstance presentIndexApiGetWith:page
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.PresentApi()
var opts = {
  'page': 1 // {Integer} 1ページ目
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.presentIndexApiGet(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class presentIndexApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new PresentApi();
            var page = 1;  // Integer | 1ページ目 (optional)  (default to null)

            try {
                // present/index_api
                apiInstance.presentIndexApiGet(page);
            } catch (Exception e) {
                Debug.Print("Exception when calling PresentApi.presentIndexApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PresentApi();
$page = 1; // Integer | 1ページ目

try {
    $api_instance->presentIndexApiGet($page);
} catch (Exception $e) {
    echo 'Exception when calling PresentApi->presentIndexApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PresentApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PresentApi->new();
my $page = 1; # Integer | 1ページ目

eval {
    $api_instance->presentIndexApiGet(page => $page);
};
if ($@) {
    warn "Exception when calling PresentApi->presentIndexApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.PresentApi()
page = 1 # Integer | 1ページ目 (optional) (default to null)

try:
    # present/index_api
    api_instance.present_index_api_get(page=page)
except ApiException as e:
    print("Exception when calling PresentApi->presentIndexApiGet: %s\n" % e)
extern crate PresentApi;

pub fn main() {
    let page = 1; // Integer

    let mut context = PresentApi::Context::default();
    let result = client.presentIndexApiGet(page, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
page
Integer
1ページ目

Responses


presentReceiveAllApiGet

present/receive_all_api


/present/receive_all_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/present/receive_all_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PresentApi;

import java.io.File;
import java.util.*;

public class PresentApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        PresentApi apiInstance = new PresentApi();

        try {
            apiInstance.presentReceiveAllApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling PresentApi#presentReceiveAllApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.PresentApi;

public class PresentApiExample {
    public static void main(String[] args) {
        PresentApi apiInstance = new PresentApi();

        try {
            apiInstance.presentReceiveAllApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling PresentApi#presentReceiveAllApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
PresentApi *apiInstance = [[PresentApi alloc] init];

// present/receive_all_api
[apiInstance presentReceiveAllApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.PresentApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.presentReceiveAllApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class presentReceiveAllApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new PresentApi();

            try {
                // present/receive_all_api
                apiInstance.presentReceiveAllApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling PresentApi.presentReceiveAllApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PresentApi();

try {
    $api_instance->presentReceiveAllApiGet();
} catch (Exception $e) {
    echo 'Exception when calling PresentApi->presentReceiveAllApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PresentApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PresentApi->new();

eval {
    $api_instance->presentReceiveAllApiGet();
};
if ($@) {
    warn "Exception when calling PresentApi->presentReceiveAllApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.PresentApi()

try:
    # present/receive_all_api
    api_instance.present_receive_all_api_get()
except ApiException as e:
    print("Exception when calling PresentApi->presentReceiveAllApiGet: %s\n" % e)
extern crate PresentApi;

pub fn main() {

    let mut context = PresentApi::Context::default();
    let result = client.presentReceiveAllApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


presentReceiveAllGet

present/receive_all


/present/receive_all

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/present/receive_all"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PresentApi;

import java.io.File;
import java.util.*;

public class PresentApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        PresentApi apiInstance = new PresentApi();

        try {
            apiInstance.presentReceiveAllGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling PresentApi#presentReceiveAllGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.PresentApi;

public class PresentApiExample {
    public static void main(String[] args) {
        PresentApi apiInstance = new PresentApi();

        try {
            apiInstance.presentReceiveAllGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling PresentApi#presentReceiveAllGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
PresentApi *apiInstance = [[PresentApi alloc] init];

// present/receive_all
[apiInstance presentReceiveAllGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.PresentApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.presentReceiveAllGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class presentReceiveAllGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new PresentApi();

            try {
                // present/receive_all
                apiInstance.presentReceiveAllGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling PresentApi.presentReceiveAllGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PresentApi();

try {
    $api_instance->presentReceiveAllGet();
} catch (Exception $e) {
    echo 'Exception when calling PresentApi->presentReceiveAllGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PresentApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PresentApi->new();

eval {
    $api_instance->presentReceiveAllGet();
};
if ($@) {
    warn "Exception when calling PresentApi->presentReceiveAllGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.PresentApi()

try:
    # present/receive_all
    api_instance.present_receive_all_get()
except ApiException as e:
    print("Exception when calling PresentApi->presentReceiveAllGet: %s\n" % e)
extern crate PresentApi;

pub fn main() {

    let mut context = PresentApi::Context::default();
    let result = client.presentReceiveAllGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


presentReceiveFinishApiGet

present/receive_finish_api


/present/receive_finish_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/present/receive_finish_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PresentApi;

import java.io.File;
import java.util.*;

public class PresentApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        PresentApi apiInstance = new PresentApi();

        try {
            apiInstance.presentReceiveFinishApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling PresentApi#presentReceiveFinishApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.PresentApi;

public class PresentApiExample {
    public static void main(String[] args) {
        PresentApi apiInstance = new PresentApi();

        try {
            apiInstance.presentReceiveFinishApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling PresentApi#presentReceiveFinishApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
PresentApi *apiInstance = [[PresentApi alloc] init];

// present/receive_finish_api
[apiInstance presentReceiveFinishApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.PresentApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.presentReceiveFinishApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class presentReceiveFinishApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new PresentApi();

            try {
                // present/receive_finish_api
                apiInstance.presentReceiveFinishApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling PresentApi.presentReceiveFinishApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PresentApi();

try {
    $api_instance->presentReceiveFinishApiGet();
} catch (Exception $e) {
    echo 'Exception when calling PresentApi->presentReceiveFinishApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PresentApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PresentApi->new();

eval {
    $api_instance->presentReceiveFinishApiGet();
};
if ($@) {
    warn "Exception when calling PresentApi->presentReceiveFinishApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.PresentApi()

try:
    # present/receive_finish_api
    api_instance.present_receive_finish_api_get()
except ApiException as e:
    print("Exception when calling PresentApi->presentReceiveFinishApiGet: %s\n" % e)
extern crate PresentApi;

pub fn main() {

    let mut context = PresentApi::Context::default();
    let result = client.presentReceiveFinishApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


presentReceiveFinishGet

present/recieve_finish


/present/receive_finish

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/present/receive_finish"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PresentApi;

import java.io.File;
import java.util.*;

public class PresentApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        PresentApi apiInstance = new PresentApi();

        try {
            apiInstance.presentReceiveFinishGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling PresentApi#presentReceiveFinishGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.PresentApi;

public class PresentApiExample {
    public static void main(String[] args) {
        PresentApi apiInstance = new PresentApi();

        try {
            apiInstance.presentReceiveFinishGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling PresentApi#presentReceiveFinishGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
PresentApi *apiInstance = [[PresentApi alloc] init];

// present/recieve_finish
[apiInstance presentReceiveFinishGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.PresentApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.presentReceiveFinishGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class presentReceiveFinishGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new PresentApi();

            try {
                // present/recieve_finish
                apiInstance.presentReceiveFinishGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling PresentApi.presentReceiveFinishGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PresentApi();

try {
    $api_instance->presentReceiveFinishGet();
} catch (Exception $e) {
    echo 'Exception when calling PresentApi->presentReceiveFinishGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PresentApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PresentApi->new();

eval {
    $api_instance->presentReceiveFinishGet();
};
if ($@) {
    warn "Exception when calling PresentApi->presentReceiveFinishGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.PresentApi()

try:
    # present/recieve_finish
    api_instance.present_receive_finish_get()
except ApiException as e:
    print("Exception when calling PresentApi->presentReceiveFinishGet: %s\n" % e)
extern crate PresentApi;

pub fn main() {

    let mut context = PresentApi::Context::default();
    let result = client.presentReceiveFinishGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


presentReceivePost

present/receive


/present/receive

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/present/receive" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PresentApi;

import java.io.File;
import java.util.*;

public class PresentApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        PresentApi apiInstance = new PresentApi();
        Object body = Object; // Object | 

        try {
            apiInstance.presentReceivePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PresentApi#presentReceivePost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.PresentApi;

public class PresentApiExample {
    public static void main(String[] args) {
        PresentApi apiInstance = new PresentApi();
        Object body = Object; // Object | 

        try {
            apiInstance.presentReceivePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PresentApi#presentReceivePost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
PresentApi *apiInstance = [[PresentApi alloc] init];
Object *body = Object; //  (optional)

// present/receive
[apiInstance presentReceivePostWith:body
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.PresentApi()
var opts = {
  'body': Object // {Object} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.presentReceivePost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class presentReceivePostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new PresentApi();
            var body = Object;  // Object |  (optional) 

            try {
                // present/receive
                apiInstance.presentReceivePost(body);
            } catch (Exception e) {
                Debug.Print("Exception when calling PresentApi.presentReceivePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PresentApi();
$body = Object; // Object | 

try {
    $api_instance->presentReceivePost($body);
} catch (Exception $e) {
    echo 'Exception when calling PresentApi->presentReceivePost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PresentApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PresentApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    $api_instance->presentReceivePost(body => $body);
};
if ($@) {
    warn "Exception when calling PresentApi->presentReceivePost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.PresentApi()
body = Object # Object |  (optional)

try:
    # present/receive
    api_instance.present_receive_post(body=body)
except ApiException as e:
    print("Exception when calling PresentApi->presentReceivePost: %s\n" % e)
extern crate PresentApi;

pub fn main() {
    let body = Object; // Object

    let mut context = PresentApi::Context::default();
    let result = client.presentReceivePost(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body

Responses


Profile

profileApiGet

profile_api


/profile_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/profile_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProfileApi;

import java.io.File;
import java.util.*;

public class ProfileApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ProfileApi apiInstance = new ProfileApi();

        try {
            apiInstance.profileApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#profileApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ProfileApi;

public class ProfileApiExample {
    public static void main(String[] args) {
        ProfileApi apiInstance = new ProfileApi();

        try {
            apiInstance.profileApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#profileApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ProfileApi *apiInstance = [[ProfileApi alloc] init];

// profile_api
[apiInstance profileApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ProfileApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.profileApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class profileApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ProfileApi();

            try {
                // profile_api
                apiInstance.profileApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ProfileApi.profileApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProfileApi();

try {
    $api_instance->profileApiGet();
} catch (Exception $e) {
    echo 'Exception when calling ProfileApi->profileApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProfileApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProfileApi->new();

eval {
    $api_instance->profileApiGet();
};
if ($@) {
    warn "Exception when calling ProfileApi->profileApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ProfileApi()

try:
    # profile_api
    api_instance.profile_api_get()
except ApiException as e:
    print("Exception when calling ProfileApi->profileApiGet: %s\n" % e)
extern crate ProfileApi;

pub fn main() {

    let mut context = ProfileApi::Context::default();
    let result = client.profileApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


profileGet

profile


/profile

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/profile"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProfileApi;

import java.io.File;
import java.util.*;

public class ProfileApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        ProfileApi apiInstance = new ProfileApi();

        try {
            apiInstance.profileGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#profileGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ProfileApi;

public class ProfileApiExample {
    public static void main(String[] args) {
        ProfileApi apiInstance = new ProfileApi();

        try {
            apiInstance.profileGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#profileGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
ProfileApi *apiInstance = [[ProfileApi alloc] init];

// profile
[apiInstance profileGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.ProfileApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.profileGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class profileGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new ProfileApi();

            try {
                // profile
                apiInstance.profileGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling ProfileApi.profileGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProfileApi();

try {
    $api_instance->profileGet();
} catch (Exception $e) {
    echo 'Exception when calling ProfileApi->profileGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProfileApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProfileApi->new();

eval {
    $api_instance->profileGet();
};
if ($@) {
    warn "Exception when calling ProfileApi->profileGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.ProfileApi()

try:
    # profile
    api_instance.profile_get()
except ApiException as e:
    print("Exception when calling ProfileApi->profileGet: %s\n" % e)
extern crate ProfileApi;

pub fn main() {

    let mut context = ProfileApi::Context::default();
    let result = client.profileGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


Rarerank

rarerankGet

rarerank


/rarerank

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/rarerank"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RarerankApi;

import java.io.File;
import java.util.*;

public class RarerankApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        RarerankApi apiInstance = new RarerankApi();

        try {
            apiInstance.rarerankGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling RarerankApi#rarerankGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RarerankApi;

public class RarerankApiExample {
    public static void main(String[] args) {
        RarerankApi apiInstance = new RarerankApi();

        try {
            apiInstance.rarerankGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling RarerankApi#rarerankGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
RarerankApi *apiInstance = [[RarerankApi alloc] init];

// rarerank
[apiInstance rarerankGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.RarerankApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.rarerankGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class rarerankGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new RarerankApi();

            try {
                // rarerank
                apiInstance.rarerankGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling RarerankApi.rarerankGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RarerankApi();

try {
    $api_instance->rarerankGet();
} catch (Exception $e) {
    echo 'Exception when calling RarerankApi->rarerankGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::RarerankApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RarerankApi->new();

eval {
    $api_instance->rarerankGet();
};
if ($@) {
    warn "Exception when calling RarerankApi->rarerankGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.RarerankApi()

try:
    # rarerank
    api_instance.rarerank_get()
except ApiException as e:
    print("Exception when calling RarerankApi->rarerankGet: %s\n" % e)
extern crate RarerankApi;

pub fn main() {

    let mut context = RarerankApi::Context::default();
    let result = client.rarerankGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


rarerankIndexApiGet

rarerank/index_api


/rarerank/index_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/rarerank/index_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RarerankApi;

import java.io.File;
import java.util.*;

public class RarerankApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        RarerankApi apiInstance = new RarerankApi();

        try {
            apiInstance.rarerankIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling RarerankApi#rarerankIndexApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RarerankApi;

public class RarerankApiExample {
    public static void main(String[] args) {
        RarerankApi apiInstance = new RarerankApi();

        try {
            apiInstance.rarerankIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling RarerankApi#rarerankIndexApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
RarerankApi *apiInstance = [[RarerankApi alloc] init];

// rarerank/index_api
[apiInstance rarerankIndexApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.RarerankApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.rarerankIndexApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class rarerankIndexApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new RarerankApi();

            try {
                // rarerank/index_api
                apiInstance.rarerankIndexApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling RarerankApi.rarerankIndexApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RarerankApi();

try {
    $api_instance->rarerankIndexApiGet();
} catch (Exception $e) {
    echo 'Exception when calling RarerankApi->rarerankIndexApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::RarerankApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RarerankApi->new();

eval {
    $api_instance->rarerankIndexApiGet();
};
if ($@) {
    warn "Exception when calling RarerankApi->rarerankIndexApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.RarerankApi()

try:
    # rarerank/index_api
    api_instance.rarerank_index_api_get()
except ApiException as e:
    print("Exception when calling RarerankApi->rarerankIndexApiGet: %s\n" % e)
extern crate RarerankApi;

pub fn main() {

    let mut context = RarerankApi::Context::default();
    let result = client.rarerankIndexApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


rarerankMonthlyApiGet

rarerank/monthly_api


/rarerank/monthly_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/rarerank/monthly_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RarerankApi;

import java.io.File;
import java.util.*;

public class RarerankApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        RarerankApi apiInstance = new RarerankApi();

        try {
            apiInstance.rarerankMonthlyApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling RarerankApi#rarerankMonthlyApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RarerankApi;

public class RarerankApiExample {
    public static void main(String[] args) {
        RarerankApi apiInstance = new RarerankApi();

        try {
            apiInstance.rarerankMonthlyApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling RarerankApi#rarerankMonthlyApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
RarerankApi *apiInstance = [[RarerankApi alloc] init];

// rarerank/monthly_api
[apiInstance rarerankMonthlyApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.RarerankApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.rarerankMonthlyApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class rarerankMonthlyApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new RarerankApi();

            try {
                // rarerank/monthly_api
                apiInstance.rarerankMonthlyApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling RarerankApi.rarerankMonthlyApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RarerankApi();

try {
    $api_instance->rarerankMonthlyApiGet();
} catch (Exception $e) {
    echo 'Exception when calling RarerankApi->rarerankMonthlyApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::RarerankApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RarerankApi->new();

eval {
    $api_instance->rarerankMonthlyApiGet();
};
if ($@) {
    warn "Exception when calling RarerankApi->rarerankMonthlyApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.RarerankApi()

try:
    # rarerank/monthly_api
    api_instance.rarerank_monthly_api_get()
except ApiException as e:
    print("Exception when calling RarerankApi->rarerankMonthlyApiGet: %s\n" % e)
extern crate RarerankApi;

pub fn main() {

    let mut context = RarerankApi::Context::default();
    let result = client.rarerankMonthlyApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


rarerankMonthlyGet

rarerank/monthly


/rarerank/monthly

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/rarerank/monthly"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RarerankApi;

import java.io.File;
import java.util.*;

public class RarerankApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        RarerankApi apiInstance = new RarerankApi();

        try {
            apiInstance.rarerankMonthlyGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling RarerankApi#rarerankMonthlyGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RarerankApi;

public class RarerankApiExample {
    public static void main(String[] args) {
        RarerankApi apiInstance = new RarerankApi();

        try {
            apiInstance.rarerankMonthlyGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling RarerankApi#rarerankMonthlyGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
RarerankApi *apiInstance = [[RarerankApi alloc] init];

// rarerank/monthly
[apiInstance rarerankMonthlyGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.RarerankApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.rarerankMonthlyGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class rarerankMonthlyGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new RarerankApi();

            try {
                // rarerank/monthly
                apiInstance.rarerankMonthlyGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling RarerankApi.rarerankMonthlyGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RarerankApi();

try {
    $api_instance->rarerankMonthlyGet();
} catch (Exception $e) {
    echo 'Exception when calling RarerankApi->rarerankMonthlyGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::RarerankApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RarerankApi->new();

eval {
    $api_instance->rarerankMonthlyGet();
};
if ($@) {
    warn "Exception when calling RarerankApi->rarerankMonthlyGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.RarerankApi()

try:
    # rarerank/monthly
    api_instance.rarerank_monthly_get()
except ApiException as e:
    print("Exception when calling RarerankApi->rarerankMonthlyGet: %s\n" % e)
extern crate RarerankApi;

pub fn main() {

    let mut context = RarerankApi::Context::default();
    let result = client.rarerankMonthlyGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


Setting

settingApiGet

setting_api


/setting_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/setting_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SettingApi;

import java.io.File;
import java.util.*;

public class SettingApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        SettingApi apiInstance = new SettingApi();

        try {
            apiInstance.settingApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SettingApi#settingApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.SettingApi;

public class SettingApiExample {
    public static void main(String[] args) {
        SettingApi apiInstance = new SettingApi();

        try {
            apiInstance.settingApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SettingApi#settingApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
SettingApi *apiInstance = [[SettingApi alloc] init];

// setting_api
[apiInstance settingApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.SettingApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.settingApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class settingApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new SettingApi();

            try {
                // setting_api
                apiInstance.settingApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling SettingApi.settingApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SettingApi();

try {
    $api_instance->settingApiGet();
} catch (Exception $e) {
    echo 'Exception when calling SettingApi->settingApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SettingApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SettingApi->new();

eval {
    $api_instance->settingApiGet();
};
if ($@) {
    warn "Exception when calling SettingApi->settingApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.SettingApi()

try:
    # setting_api
    api_instance.setting_api_get()
except ApiException as e:
    print("Exception when calling SettingApi->settingApiGet: %s\n" % e)
extern crate SettingApi;

pub fn main() {

    let mut context = SettingApi::Context::default();
    let result = client.settingApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


settingGet

setting


/setting

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/setting"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SettingApi;

import java.io.File;
import java.util.*;

public class SettingApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        SettingApi apiInstance = new SettingApi();

        try {
            apiInstance.settingGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SettingApi#settingGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.SettingApi;

public class SettingApiExample {
    public static void main(String[] args) {
        SettingApi apiInstance = new SettingApi();

        try {
            apiInstance.settingGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling SettingApi#settingGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
SettingApi *apiInstance = [[SettingApi alloc] init];

// setting
[apiInstance settingGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.SettingApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.settingGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class settingGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new SettingApi();

            try {
                // setting
                apiInstance.settingGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling SettingApi.settingGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SettingApi();

try {
    $api_instance->settingGet();
} catch (Exception $e) {
    echo 'Exception when calling SettingApi->settingGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SettingApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SettingApi->new();

eval {
    $api_instance->settingGet();
};
if ($@) {
    warn "Exception when calling SettingApi->settingGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.SettingApi()

try:
    # setting
    api_instance.setting_get()
except ApiException as e:
    print("Exception when calling SettingApi->settingGet: %s\n" % e)
extern crate SettingApi;

pub fn main() {

    let mut context = SettingApi::Context::default();
    let result = client.settingGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


Top

topIndexApiGet

top/index_api


/top/index_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/top/index_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.TopApi;

import java.io.File;
import java.util.*;

public class TopApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        TopApi apiInstance = new TopApi();

        try {
            apiInstance.topIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling TopApi#topIndexApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.TopApi;

public class TopApiExample {
    public static void main(String[] args) {
        TopApi apiInstance = new TopApi();

        try {
            apiInstance.topIndexApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling TopApi#topIndexApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
TopApi *apiInstance = [[TopApi alloc] init];

// top/index_api
[apiInstance topIndexApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.TopApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.topIndexApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class topIndexApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new TopApi();

            try {
                // top/index_api
                apiInstance.topIndexApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling TopApi.topIndexApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TopApi();

try {
    $api_instance->topIndexApiGet();
} catch (Exception $e) {
    echo 'Exception when calling TopApi->topIndexApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::TopApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TopApi->new();

eval {
    $api_instance->topIndexApiGet();
};
if ($@) {
    warn "Exception when calling TopApi->topIndexApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.TopApi()

try:
    # top/index_api
    api_instance.top_index_api_get()
except ApiException as e:
    print("Exception when calling TopApi->topIndexApiGet: %s\n" % e)
extern crate TopApi;

pub fn main() {

    let mut context = TopApi::Context::default();
    let result = client.topIndexApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


topIndexGet

top/index


/top/index

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/top/index"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.TopApi;

import java.io.File;
import java.util.*;

public class TopApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        TopApi apiInstance = new TopApi();

        try {
            apiInstance.topIndexGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling TopApi#topIndexGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.TopApi;

public class TopApiExample {
    public static void main(String[] args) {
        TopApi apiInstance = new TopApi();

        try {
            apiInstance.topIndexGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling TopApi#topIndexGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
TopApi *apiInstance = [[TopApi alloc] init];

// top/index
[apiInstance topIndexGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.TopApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.topIndexGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class topIndexGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new TopApi();

            try {
                // top/index
                apiInstance.topIndexGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling TopApi.topIndexGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TopApi();

try {
    $api_instance->topIndexGet();
} catch (Exception $e) {
    echo 'Exception when calling TopApi->topIndexGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::TopApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TopApi->new();

eval {
    $api_instance->topIndexGet();
};
if ($@) {
    warn "Exception when calling TopApi->topIndexGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.TopApi()

try:
    # top/index
    api_instance.top_index_get()
except ApiException as e:
    print("Exception when calling TopApi->topIndexGet: %s\n" % e)
extern crate TopApi;

pub fn main() {

    let mut context = TopApi::Context::default();
    let result = client.topIndexGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


Trophy

trophyApiGet

trophy_api


/trophy_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/trophy_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.TrophyApi;

import java.io.File;
import java.util.*;

public class TrophyApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        TrophyApi apiInstance = new TrophyApi();

        try {
            apiInstance.trophyApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling TrophyApi#trophyApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.TrophyApi;

public class TrophyApiExample {
    public static void main(String[] args) {
        TrophyApi apiInstance = new TrophyApi();

        try {
            apiInstance.trophyApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling TrophyApi#trophyApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
TrophyApi *apiInstance = [[TrophyApi alloc] init];

// trophy_api
[apiInstance trophyApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.TrophyApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.trophyApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class trophyApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new TrophyApi();

            try {
                // trophy_api
                apiInstance.trophyApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling TrophyApi.trophyApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TrophyApi();

try {
    $api_instance->trophyApiGet();
} catch (Exception $e) {
    echo 'Exception when calling TrophyApi->trophyApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::TrophyApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TrophyApi->new();

eval {
    $api_instance->trophyApiGet();
};
if ($@) {
    warn "Exception when calling TrophyApi->trophyApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.TrophyApi()

try:
    # trophy_api
    api_instance.trophy_api_get()
except ApiException as e:
    print("Exception when calling TrophyApi->trophyApiGet: %s\n" % e)
extern crate TrophyApi;

pub fn main() {

    let mut context = TrophyApi::Context::default();
    let result = client.trophyApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


trophyGet

trophy


/trophy

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/trophy"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.TrophyApi;

import java.io.File;
import java.util.*;

public class TrophyApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        TrophyApi apiInstance = new TrophyApi();

        try {
            apiInstance.trophyGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling TrophyApi#trophyGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.TrophyApi;

public class TrophyApiExample {
    public static void main(String[] args) {
        TrophyApi apiInstance = new TrophyApi();

        try {
            apiInstance.trophyGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling TrophyApi#trophyGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
TrophyApi *apiInstance = [[TrophyApi alloc] init];

// trophy
[apiInstance trophyGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.TrophyApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.trophyGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class trophyGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new TrophyApi();

            try {
                // trophy
                apiInstance.trophyGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling TrophyApi.trophyGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TrophyApi();

try {
    $api_instance->trophyGet();
} catch (Exception $e) {
    echo 'Exception when calling TrophyApi->trophyGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::TrophyApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TrophyApi->new();

eval {
    $api_instance->trophyGet();
};
if ($@) {
    warn "Exception when calling TrophyApi->trophyGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.TrophyApi()

try:
    # trophy
    api_instance.trophy_get()
except ApiException as e:
    print("Exception when calling TrophyApi->trophyGet: %s\n" % e)
extern crate TrophyApi;

pub fn main() {

    let mut context = TrophyApi::Context::default();
    let result = client.trophyGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


Tutorial

tutorialNaviApiGet

tutorial/navi_api


/tutorial/navi_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/tutorial/navi_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.TutorialApi;

import java.io.File;
import java.util.*;

public class TutorialApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        TutorialApi apiInstance = new TutorialApi();

        try {
            apiInstance.tutorialNaviApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling TutorialApi#tutorialNaviApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.TutorialApi;

public class TutorialApiExample {
    public static void main(String[] args) {
        TutorialApi apiInstance = new TutorialApi();

        try {
            apiInstance.tutorialNaviApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling TutorialApi#tutorialNaviApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
TutorialApi *apiInstance = [[TutorialApi alloc] init];

// tutorial/navi_api
[apiInstance tutorialNaviApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.TutorialApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.tutorialNaviApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class tutorialNaviApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new TutorialApi();

            try {
                // tutorial/navi_api
                apiInstance.tutorialNaviApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling TutorialApi.tutorialNaviApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TutorialApi();

try {
    $api_instance->tutorialNaviApiGet();
} catch (Exception $e) {
    echo 'Exception when calling TutorialApi->tutorialNaviApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::TutorialApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TutorialApi->new();

eval {
    $api_instance->tutorialNaviApiGet();
};
if ($@) {
    warn "Exception when calling TutorialApi->tutorialNaviApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.TutorialApi()

try:
    # tutorial/navi_api
    api_instance.tutorial_navi_api_get()
except ApiException as e:
    print("Exception when calling TutorialApi->tutorialNaviApiGet: %s\n" % e)
extern crate TutorialApi;

pub fn main() {

    let mut context = TutorialApi::Context::default();
    let result = client.tutorialNaviApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


tutorialNaviGet

tutorial/navi


/tutorial/navi

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/tutorial/navi"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.TutorialApi;

import java.io.File;
import java.util.*;

public class TutorialApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        TutorialApi apiInstance = new TutorialApi();

        try {
            apiInstance.tutorialNaviGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling TutorialApi#tutorialNaviGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.TutorialApi;

public class TutorialApiExample {
    public static void main(String[] args) {
        TutorialApi apiInstance = new TutorialApi();

        try {
            apiInstance.tutorialNaviGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling TutorialApi#tutorialNaviGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
TutorialApi *apiInstance = [[TutorialApi alloc] init];

// tutorial/navi
[apiInstance tutorialNaviGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.TutorialApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.tutorialNaviGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class tutorialNaviGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new TutorialApi();

            try {
                // tutorial/navi
                apiInstance.tutorialNaviGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling TutorialApi.tutorialNaviGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TutorialApi();

try {
    $api_instance->tutorialNaviGet();
} catch (Exception $e) {
    echo 'Exception when calling TutorialApi->tutorialNaviGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::TutorialApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TutorialApi->new();

eval {
    $api_instance->tutorialNaviGet();
};
if ($@) {
    warn "Exception when calling TutorialApi->tutorialNaviGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.TutorialApi()

try:
    # tutorial/navi
    api_instance.tutorial_navi_get()
except ApiException as e:
    print("Exception when calling TutorialApi->tutorialNaviGet: %s\n" % e)
extern crate TutorialApi;

pub fn main() {

    let mut context = TutorialApi::Context::default();
    let result = client.tutorialNaviGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


User

userCrystalPurchaseApiGet

user/crystal_purchase_api


/user/crystal_purchase_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/user/crystal_purchase_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UserApi;

import java.io.File;
import java.util.*;

public class UserApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        UserApi apiInstance = new UserApi();

        try {
            apiInstance.userCrystalPurchaseApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#userCrystalPurchaseApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.UserApi;

public class UserApiExample {
    public static void main(String[] args) {
        UserApi apiInstance = new UserApi();

        try {
            apiInstance.userCrystalPurchaseApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#userCrystalPurchaseApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
UserApi *apiInstance = [[UserApi alloc] init];

// user/crystal_purchase_api
[apiInstance userCrystalPurchaseApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.UserApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.userCrystalPurchaseApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class userCrystalPurchaseApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new UserApi();

            try {
                // user/crystal_purchase_api
                apiInstance.userCrystalPurchaseApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling UserApi.userCrystalPurchaseApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserApi();

try {
    $api_instance->userCrystalPurchaseApiGet();
} catch (Exception $e) {
    echo 'Exception when calling UserApi->userCrystalPurchaseApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserApi->new();

eval {
    $api_instance->userCrystalPurchaseApiGet();
};
if ($@) {
    warn "Exception when calling UserApi->userCrystalPurchaseApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.UserApi()

try:
    # user/crystal_purchase_api
    api_instance.user_crystal_purchase_api_get()
except ApiException as e:
    print("Exception when calling UserApi->userCrystalPurchaseApiGet: %s\n" % e)
extern crate UserApi;

pub fn main() {

    let mut context = UserApi::Context::default();
    let result = client.userCrystalPurchaseApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


userCrystalPurchaseGet

user/crystal_purchase


/user/crystal_purchase

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/user/crystal_purchase"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UserApi;

import java.io.File;
import java.util.*;

public class UserApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        UserApi apiInstance = new UserApi();

        try {
            apiInstance.userCrystalPurchaseGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#userCrystalPurchaseGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.UserApi;

public class UserApiExample {
    public static void main(String[] args) {
        UserApi apiInstance = new UserApi();

        try {
            apiInstance.userCrystalPurchaseGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling UserApi#userCrystalPurchaseGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
UserApi *apiInstance = [[UserApi alloc] init];

// user/crystal_purchase
[apiInstance userCrystalPurchaseGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.UserApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.userCrystalPurchaseGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class userCrystalPurchaseGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new UserApi();

            try {
                // user/crystal_purchase
                apiInstance.userCrystalPurchaseGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling UserApi.userCrystalPurchaseGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserApi();

try {
    $api_instance->userCrystalPurchaseGet();
} catch (Exception $e) {
    echo 'Exception when calling UserApi->userCrystalPurchaseGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserApi->new();

eval {
    $api_instance->userCrystalPurchaseGet();
};
if ($@) {
    warn "Exception when calling UserApi->userCrystalPurchaseGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.UserApi()

try:
    # user/crystal_purchase
    api_instance.user_crystal_purchase_get()
except ApiException as e:
    print("Exception when calling UserApi->userCrystalPurchaseGet: %s\n" % e)
extern crate UserApi;

pub fn main() {

    let mut context = UserApi::Context::default();
    let result = client.userCrystalPurchaseGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


UserPolicy

userPolicyActOnSettlementApiGet

user_policy/act_on_settlement_api


/user_policy/act_on_settlement_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/user_policy/act_on_settlement_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UserPolicyApi;

import java.io.File;
import java.util.*;

public class UserPolicyApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        UserPolicyApi apiInstance = new UserPolicyApi();

        try {
            apiInstance.userPolicyActOnSettlementApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling UserPolicyApi#userPolicyActOnSettlementApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.UserPolicyApi;

public class UserPolicyApiExample {
    public static void main(String[] args) {
        UserPolicyApi apiInstance = new UserPolicyApi();

        try {
            apiInstance.userPolicyActOnSettlementApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling UserPolicyApi#userPolicyActOnSettlementApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
UserPolicyApi *apiInstance = [[UserPolicyApi alloc] init];

// user_policy/act_on_settlement_api
[apiInstance userPolicyActOnSettlementApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.UserPolicyApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.userPolicyActOnSettlementApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class userPolicyActOnSettlementApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new UserPolicyApi();

            try {
                // user_policy/act_on_settlement_api
                apiInstance.userPolicyActOnSettlementApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling UserPolicyApi.userPolicyActOnSettlementApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserPolicyApi();

try {
    $api_instance->userPolicyActOnSettlementApiGet();
} catch (Exception $e) {
    echo 'Exception when calling UserPolicyApi->userPolicyActOnSettlementApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserPolicyApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserPolicyApi->new();

eval {
    $api_instance->userPolicyActOnSettlementApiGet();
};
if ($@) {
    warn "Exception when calling UserPolicyApi->userPolicyActOnSettlementApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.UserPolicyApi()

try:
    # user_policy/act_on_settlement_api
    api_instance.user_policy_act_on_settlement_api_get()
except ApiException as e:
    print("Exception when calling UserPolicyApi->userPolicyActOnSettlementApiGet: %s\n" % e)
extern crate UserPolicyApi;

pub fn main() {

    let mut context = UserPolicyApi::Context::default();
    let result = client.userPolicyActOnSettlementApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


userPolicyActOnSettlementGet

user_policy/act_on_settlement


/user_policy/act_on_settlement

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/user_policy/act_on_settlement"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UserPolicyApi;

import java.io.File;
import java.util.*;

public class UserPolicyApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        UserPolicyApi apiInstance = new UserPolicyApi();

        try {
            apiInstance.userPolicyActOnSettlementGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling UserPolicyApi#userPolicyActOnSettlementGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.UserPolicyApi;

public class UserPolicyApiExample {
    public static void main(String[] args) {
        UserPolicyApi apiInstance = new UserPolicyApi();

        try {
            apiInstance.userPolicyActOnSettlementGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling UserPolicyApi#userPolicyActOnSettlementGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
UserPolicyApi *apiInstance = [[UserPolicyApi alloc] init];

// user_policy/act_on_settlement
[apiInstance userPolicyActOnSettlementGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.UserPolicyApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.userPolicyActOnSettlementGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class userPolicyActOnSettlementGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new UserPolicyApi();

            try {
                // user_policy/act_on_settlement
                apiInstance.userPolicyActOnSettlementGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling UserPolicyApi.userPolicyActOnSettlementGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserPolicyApi();

try {
    $api_instance->userPolicyActOnSettlementGet();
} catch (Exception $e) {
    echo 'Exception when calling UserPolicyApi->userPolicyActOnSettlementGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserPolicyApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserPolicyApi->new();

eval {
    $api_instance->userPolicyActOnSettlementGet();
};
if ($@) {
    warn "Exception when calling UserPolicyApi->userPolicyActOnSettlementGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.UserPolicyApi()

try:
    # user_policy/act_on_settlement
    api_instance.user_policy_act_on_settlement_get()
except ApiException as e:
    print("Exception when calling UserPolicyApi->userPolicyActOnSettlementGet: %s\n" % e)
extern crate UserPolicyApi;

pub fn main() {

    let mut context = UserPolicyApi::Context::default();
    let result = client.userPolicyActOnSettlementGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


userPolicyTokushoApiGet

user_policy/tokusho_api


/user_policy/tokusho_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/user_policy/tokusho_api"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UserPolicyApi;

import java.io.File;
import java.util.*;

public class UserPolicyApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        UserPolicyApi apiInstance = new UserPolicyApi();

        try {
            apiInstance.userPolicyTokushoApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling UserPolicyApi#userPolicyTokushoApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.UserPolicyApi;

public class UserPolicyApiExample {
    public static void main(String[] args) {
        UserPolicyApi apiInstance = new UserPolicyApi();

        try {
            apiInstance.userPolicyTokushoApiGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling UserPolicyApi#userPolicyTokushoApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
UserPolicyApi *apiInstance = [[UserPolicyApi alloc] init];

// user_policy/tokusho_api
[apiInstance userPolicyTokushoApiGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.UserPolicyApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.userPolicyTokushoApiGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class userPolicyTokushoApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new UserPolicyApi();

            try {
                // user_policy/tokusho_api
                apiInstance.userPolicyTokushoApiGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling UserPolicyApi.userPolicyTokushoApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserPolicyApi();

try {
    $api_instance->userPolicyTokushoApiGet();
} catch (Exception $e) {
    echo 'Exception when calling UserPolicyApi->userPolicyTokushoApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserPolicyApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserPolicyApi->new();

eval {
    $api_instance->userPolicyTokushoApiGet();
};
if ($@) {
    warn "Exception when calling UserPolicyApi->userPolicyTokushoApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.UserPolicyApi()

try:
    # user_policy/tokusho_api
    api_instance.user_policy_tokusho_api_get()
except ApiException as e:
    print("Exception when calling UserPolicyApi->userPolicyTokushoApiGet: %s\n" % e)
extern crate UserPolicyApi;

pub fn main() {

    let mut context = UserPolicyApi::Context::default();
    let result = client.userPolicyTokushoApiGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


userPolicyTokushoGet

user_policy/tokusho


/user_policy/tokusho

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/user_policy/tokusho"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UserPolicyApi;

import java.io.File;
import java.util.*;

public class UserPolicyApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        UserPolicyApi apiInstance = new UserPolicyApi();

        try {
            apiInstance.userPolicyTokushoGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling UserPolicyApi#userPolicyTokushoGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.UserPolicyApi;

public class UserPolicyApiExample {
    public static void main(String[] args) {
        UserPolicyApi apiInstance = new UserPolicyApi();

        try {
            apiInstance.userPolicyTokushoGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling UserPolicyApi#userPolicyTokushoGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
UserPolicyApi *apiInstance = [[UserPolicyApi alloc] init];

// user_policy/tokusho
[apiInstance userPolicyTokushoGetWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.UserPolicyApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.userPolicyTokushoGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class userPolicyTokushoGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new UserPolicyApi();

            try {
                // user_policy/tokusho
                apiInstance.userPolicyTokushoGet();
            } catch (Exception e) {
                Debug.Print("Exception when calling UserPolicyApi.userPolicyTokushoGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserPolicyApi();

try {
    $api_instance->userPolicyTokushoGet();
} catch (Exception $e) {
    echo 'Exception when calling UserPolicyApi->userPolicyTokushoGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserPolicyApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserPolicyApi->new();

eval {
    $api_instance->userPolicyTokushoGet();
};
if ($@) {
    warn "Exception when calling UserPolicyApi->userPolicyTokushoGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.UserPolicyApi()

try:
    # user_policy/tokusho
    api_instance.user_policy_tokusho_get()
except ApiException as e:
    print("Exception when calling UserPolicyApi->userPolicyTokushoGet: %s\n" % e)
extern crate UserPolicyApi;

pub fn main() {

    let mut context = UserPolicyApi::Context::default();
    let result = client.userPolicyTokushoGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


Valentine2021Vote

valentine2021VoteGet

valentine2021_vote


/valentine2021_vote

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/valentine2021_vote?target_year=yyyy"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.Valentine2021VoteApi;

import java.io.File;
import java.util.*;

public class Valentine2021VoteApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        Valentine2021VoteApi apiInstance = new Valentine2021VoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.valentine2021VoteGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling Valentine2021VoteApi#valentine2021VoteGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.Valentine2021VoteApi;

public class Valentine2021VoteApiExample {
    public static void main(String[] args) {
        Valentine2021VoteApi apiInstance = new Valentine2021VoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.valentine2021VoteGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling Valentine2021VoteApi#valentine2021VoteGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
Valentine2021VoteApi *apiInstance = [[Valentine2021VoteApi alloc] init];
String *userAgent = userAgent_example; //  (optional) (default to null)
String *targetYear = yyyy; //  (optional) (default to null)

// valentine2021_vote
[apiInstance valentine2021VoteGetWith:userAgent
    targetYear:targetYear
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.Valentine2021VoteApi()
var opts = {
  'userAgent': userAgent_example, // {String} 
  'targetYear': yyyy // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.valentine2021VoteGet(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class valentine2021VoteGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new Valentine2021VoteApi();
            var userAgent = userAgent_example;  // String |  (optional)  (default to null)
            var targetYear = yyyy;  // String |  (optional)  (default to null)

            try {
                // valentine2021_vote
                apiInstance.valentine2021VoteGet(userAgent, targetYear);
            } catch (Exception e) {
                Debug.Print("Exception when calling Valentine2021VoteApi.valentine2021VoteGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Valentine2021VoteApi();
$userAgent = userAgent_example; // String | 
$targetYear = yyyy; // String | 

try {
    $api_instance->valentine2021VoteGet($userAgent, $targetYear);
} catch (Exception $e) {
    echo 'Exception when calling Valentine2021VoteApi->valentine2021VoteGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Valentine2021VoteApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::Valentine2021VoteApi->new();
my $userAgent = userAgent_example; # String | 
my $targetYear = yyyy; # String | 

eval {
    $api_instance->valentine2021VoteGet(userAgent => $userAgent, targetYear => $targetYear);
};
if ($@) {
    warn "Exception when calling Valentine2021VoteApi->valentine2021VoteGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.Valentine2021VoteApi()
userAgent = userAgent_example # String |  (optional) (default to null)
targetYear = yyyy # String |  (optional) (default to null)

try:
    # valentine2021_vote
    api_instance.valentine2021_vote_get(userAgent=userAgent, targetYear=targetYear)
except ApiException as e:
    print("Exception when calling Valentine2021VoteApi->valentine2021VoteGet: %s\n" % e)
extern crate Valentine2021VoteApi;

pub fn main() {
    let userAgent = userAgent_example; // String
    let targetYear = yyyy; // String

    let mut context = Valentine2021VoteApi::Context::default();
    let result = client.valentine2021VoteGet(userAgent, targetYear, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Header parameters
Name Description
User-Agent
String
Query parameters
Name Description
target_year
String

Responses


valentine2021VoteIndexApiGet

valentine2021_vote/index_api


/valentine2021_vote/index_api

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Basic [[basicHash]]" \
 -H "Accept: application/json" \
 "http://localhost/valentine2021_vote/index_api?target_year=yyyy"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.Valentine2021VoteApi;

import java.io.File;
import java.util.*;

public class Valentine2021VoteApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        // Create an instance of the API class
        Valentine2021VoteApi apiInstance = new Valentine2021VoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.valentine2021VoteIndexApiGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling Valentine2021VoteApi#valentine2021VoteIndexApiGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.Valentine2021VoteApi;

public class Valentine2021VoteApiExample {
    public static void main(String[] args) {
        Valentine2021VoteApi apiInstance = new Valentine2021VoteApi();
        String userAgent = userAgent_example; // String | 
        String targetYear = yyyy; // String | 

        try {
            apiInstance.valentine2021VoteIndexApiGet(userAgent, targetYear);
        } catch (ApiException e) {
            System.err.println("Exception when calling Valentine2021VoteApi#valentine2021VoteIndexApiGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

// Create an instance of the API class
Valentine2021VoteApi *apiInstance = [[Valentine2021VoteApi alloc] init];
String *userAgent = userAgent_example; //  (optional) (default to null)
String *targetYear = yyyy; //  (optional) (default to null)

// valentine2021_vote/index_api
[apiInstance valentine2021VoteIndexApiGetWith:userAgent
    targetYear:targetYear
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ApiReference = require('api_reference');
var defaultClient = ApiReference.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME';
basicAuth.password = 'YOUR PASSWORD';

// Create an instance of the API class
var api = new ApiReference.Valentine2021VoteApi()
var opts = {
  'userAgent': userAgent_example, // {String} 
  'targetYear': yyyy // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.valentine2021VoteIndexApiGet(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class valentine2021VoteIndexApiGetExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            // Create an instance of the API class
            var apiInstance = new Valentine2021VoteApi();
            var userAgent = userAgent_example;  // String |  (optional)  (default to null)
            var targetYear = yyyy;  // String |  (optional)  (default to null)

            try {
                // valentine2021_vote/index_api
                apiInstance.valentine2021VoteIndexApiGet(userAgent, targetYear);
            } catch (Exception e) {
                Debug.Print("Exception when calling Valentine2021VoteApi.valentine2021VoteIndexApiGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: basicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Valentine2021VoteApi();
$userAgent = userAgent_example; // String | 
$targetYear = yyyy; // String | 

try {
    $api_instance->valentine2021VoteIndexApiGet($userAgent, $targetYear);
} catch (Exception $e) {
    echo 'Exception when calling Valentine2021VoteApi->valentine2021VoteIndexApiGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Valentine2021VoteApi;

# Configure HTTP basic authorization: basicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::Valentine2021VoteApi->new();
my $userAgent = userAgent_example; # String | 
my $targetYear = yyyy; # String | 

eval {
    $api_instance->valentine2021VoteIndexApiGet(userAgent => $userAgent, targetYear => $targetYear);
};
if ($@) {
    warn "Exception when calling Valentine2021VoteApi->valentine2021VoteIndexApiGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Create an instance of the API class
api_instance = openapi_client.Valentine2021VoteApi()
userAgent = userAgent_example # String |  (optional) (default to null)
targetYear = yyyy # String |  (optional) (default to null)

try:
    # valentine2021_vote/index_api
    api_instance.valentine2021_vote_index_api_get(userAgent=userAgent, targetYear=targetYear)
except ApiException as e:
    print("Exception when calling Valentine2021VoteApi->valentine2021VoteIndexApiGet: %s\n" % e)
extern crate Valentine2021VoteApi;

pub fn main() {
    let userAgent = userAgent_example; // String
    let targetYear = yyyy; // String

    let mut context = Valentine2021VoteApi::Context::default();
    let result = client.valentine2021VoteIndexApiGet(userAgent, targetYear, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Header parameters
Name Description
User-Agent
String
Query parameters
Name Description
target_year
String

Responses